Fix the behavior of HAVING clause (#154)

The current implementation has a special handling for `HAVING` clauses
without `GROUP BY` (this is [valid in
MySQL](https://stackoverflow.com/questions/6924896/having-without-group-by)
in some SQL modes). This implementation takes advantage of the
equivalence of ungrouped HAVING with WHERE and rewrites such a `HAVING
<condition>` clause to `AND <condition>`.

However, the current implementation has some issues:
1. The presence of `GROUP BY` in a query is incorrectly detected. The
detection always fails, and thus every HAVING query is considered to be
ungrouped. I added a fix in the first commit.
2. Rewriting `HAVING <condition>` to `AND <condition>` fails with an
error `near "AND": syntax error` when no WHERE is included in the query.
This is fixed in the second commit.
3. When an aggregate function is used in HAVING (e.g, `COUNT(*) > 1`),
the query fails with: `misuse of aggregate function COUNT()`. This is
because aggregate functions can't be used in the WHERE clause. This is
fixed in the second commit.

To fix all of these issues, I implemented a fix for the `GROUP BY`
detection (case 1), and changed the rewriting of `HAVING <condition>`
without `GROUP BY` to `GROUP BY 1 HAVING <condition>` (which fixes both
case 2 and 3).

Author: JanJakes

tests/WP_SQLite_Translator_Tests.php

@@ -3133,6 +3133,85 @@ public function testCurrentTimestamp() {
 		$this->assertQuery( 'DELETE FROM _dates WHERE option_value = CURRENT_TIMESTAMP()' );
 	}
 
+	public function testGroupByHaving() {
+		$this->assertQuery(
+			'CREATE TABLE _tmp_table (
+				name varchar(20)
+			);'
+		);
+
+		$this->assertQuery(
+			"INSERT INTO _tmp_table VALUES ('a'), ('b'), ('b'), ('c'), ('c'), ('c')"
+		);
+
+		$result = $this->assertQuery(
+			'SELECT name, COUNT(*) as count FROM _tmp_table GROUP BY name HAVING COUNT(*) > 1'
+		);
+		$this->assertEquals(
+			array(
+				(object) array(
+					'name'  => 'b',
+					'count' => '2',
+				),
+				(object) array(
+					'name'  => 'c',
+					'count' => '3',
+				),
+			),
+			$result
+		);
+	}
+
+	public function testHavingWithoutGroupBy() {
+		$this->assertQuery(
+			'CREATE TABLE _tmp_table (
+				name varchar(20)
+			);'
+		);
+
+		$this->assertQuery(
+			"INSERT INTO _tmp_table VALUES ('a'), ('b'), ('b'), ('c'), ('c'), ('c')"
+		);
+
+		// HAVING condition satisfied
+		$result = $this->assertQuery(
+			"SELECT 'T' FROM _tmp_table HAVING COUNT(*) > 1"
+		);
+		$this->assertEquals(
+			array(
+				(object) array(
+					':param0' => 'T',
+				),
+			),
+			$result
+		);
+
+		// HAVING condition not satisfied
+		$result = $this->assertQuery(
+			"SELECT 'T' FROM _tmp_table HAVING COUNT(*) > 100"
+		);
+		$this->assertEquals(
+			array(),
+			$result
+		);
+
+		// DISTINCT ... HAVING, where only some results meet the HAVING condition
+		$result = $this->assertQuery(
+			'SELECT DISTINCT name FROM _tmp_table HAVING COUNT(*) > 1'
+		);
+		$this->assertEquals(
+			array(
+				(object) array(
+					'name' => 'b',
+				),
+				(object) array(
+					'name' => 'c',
+				),
+			),
+			$result
+		);
+	}
+
 	/**
 	 * @dataProvider mysqlVariablesToTest
 	 */

wp-includes/sqlite/class-wp-sqlite-translator.php

@@ -2659,23 +2659,19 @@ private function capture_group_by( $token ) {
 			! $token->matches(
 				WP_SQLite_Token::TYPE_KEYWORD,
 				WP_SQLite_Token::FLAG_KEYWORD_RESERVED,
-				array( 'GROUP' )
+				array( 'GROUP BY' )
 			)
 		) {
 			return false;
 		}
-		$next = $this->rewriter->peek_nth( 2 )->value;
-		if ( 'BY' !== strtoupper( $next ?? '' ) ) {
-			return false;
-		}
 
 		$this->has_group_by = true;
 
 		return false;
 	}
 
 	/**
-	 * Translate WHERE something HAVING something to WHERE something AND something.
+	 * Translate HAVING without GROUP BY to GROUP BY 1 HAVING.
 	 *
 	 * @param WP_SQLite_Token $token The token to translate.
 	 *
@@ -2694,8 +2690,15 @@ private function translate_ungrouped_having( $token ) {
 		if ( $this->has_group_by ) {
 			return false;
 		}
-		$this->rewriter->skip();
-		$this->rewriter->add( new WP_SQLite_Token( 'AND', WP_SQLite_Token::TYPE_KEYWORD ) );
+
+		// GROUP BY is missing, add "GROUP BY 1" before the HAVING clause.
+		$having = $this->rewriter->skip();
+		$this->rewriter->add( new WP_SQLite_Token( ' ', WP_SQLite_Token::TYPE_DELIMITER ) );
+		$this->rewriter->add( new WP_SQLite_Token( 'GROUP BY', WP_SQLite_Token::TYPE_KEYWORD ) );
+		$this->rewriter->add( new WP_SQLite_Token( ' ', WP_SQLite_Token::TYPE_DELIMITER ) );
+		$this->rewriter->add( new WP_SQLite_Token( '1', WP_SQLite_Token::TYPE_NUMBER ) );
+		$this->rewriter->add( new WP_SQLite_Token( ' ', WP_SQLite_Token::TYPE_DELIMITER ) );
+		$this->rewriter->add( $having );
 
 		return true;
 	}