remove BQ parser, handle distinct in duck generator

Author: treysp

sqlglot/dialects/bigquery.py

@@ -625,7 +625,6 @@ class Parser(parser.Parser):
                 exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
             ),
             "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
-            "APPROX_QUANTILES": lambda self: self._parse_approx_quantiles(),
             "PREDICT": lambda self: self._parse_ml(exp.Predict),
             "TRANSLATE": lambda self: self._parse_translate(),
             "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
@@ -919,21 +918,6 @@ def _parse_make_interval(self) -> exp.MakeInterval:
 
             return expr
 
-        def _parse_approx_quantiles(self) -> t.Optional[exp.Expression]:
-            # APPROX_QUANTILES([DISTINCT] expression, number [{IGNORE | RESPECT} NULLS])
-            distinct = self._match(TokenType.DISTINCT)
-            this = self._parse_disjunction()
-            if distinct:
-                this = self.expression(exp.Distinct, expressions=[this])
-
-            self._match(TokenType.COMMA)
-            expression = self._parse_bitwise()
-            if not expression:
-                self.raise_error("Expected number of quantiles argument in APPROX_QUANTILES")
-
-            func = self.expression(exp.ApproxQuantiles, this=this, expression=expression)
-            return self._parse_respect_or_ignore_nulls(func)
-
         def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
             self._match_text_seq("MODEL")
             this = self._parse_table()

sqlglot/dialects/duckdb.py

@@ -152,16 +152,19 @@ def _approx_quantiles_sql(self: DuckDB.Generator, expression: exp.ApproxQuantile
     BigQuery's APPROX_QUANTILES(expr, n) returns an array of n+1 approximate quantile values
     dividing the input distribution into n equal-sized buckets.
 
-    This is transpiled to DuckDB as an array of individual APPROX_QUANTILE calls for each
-    quantile value (0/n, 1/n, 2/n, ..., n/n):
-
-    APPROX_QUANTILES(x, 2) -> [APPROX_QUANTILE(x, 0), APPROX_QUANTILE(x, 0.5), APPROX_QUANTILE(x, 1)]
-
     Both BigQuery and DuckDB use approximate algorithms for quantile estimation, but BigQuery
-    does not document the specific algorithm used so results may differ.
+    does not document the specific algorithm used so results may differ. DuckDB does not
+    support RESPECT NULLS.
     """
     this = expression.this
-    num_quantiles_expr = expression.expression
+    if isinstance(this, exp.Distinct):
+        # APPROX_QUANTILES requires 2 args and DISTINCT node grabs both
+        if len(this.expressions) < 2:
+            self.unsupported("APPROX_QUANTILES requires a bucket count argument")
+            return self.function_fallback_sql(expression)
+        num_quantiles_expr = this.expressions.pop(1)
+    else:
+        num_quantiles_expr = expression.expression
 
     if isinstance(num_quantiles_expr, (exp.Cast, exp.TryCast)):
         num_quantiles_expr = num_quantiles_expr.this.unnest()

tests/dialects/test_bigquery.py

@@ -3513,6 +3513,18 @@ def test_approx_quantiles_to_duckdb(self):
                     "duckdb", unsupported_level=ErrorLevel.RAISE
                 )
 
+        with self.subTest("missing bucket count"):
+            with self.assertRaises(UnsupportedError):
+                self.parse_one("APPROX_QUANTILES(x)").sql(
+                    "duckdb", unsupported_level=ErrorLevel.RAISE
+                )
+
+        with self.subTest("missing bucket count with DISTINCT"):
+            with self.assertRaises(UnsupportedError):
+                self.parse_one("APPROX_QUANTILES(DISTINCT x)").sql(
+                    "duckdb", unsupported_level=ErrorLevel.RAISE
+                )
+
         with self.subTest("APPROX_QUANTILES IGNORE NULLS"):
             # No warning: IGNORE NULLS is the default behavior in DuckDB
             from sqlglot.generator import logger as generator_logger