refactor: add agg_ops.ApproxQuartilesOp to sqlglot compiler

Author: chelsea-lin

bigframes/core/compile/sqlglot/aggregations/op_registration.py

@@ -41,12 +41,9 @@ def arg_checker(*args, **kwargs):
                     )
                 return item(*args, **kwargs)
 
-            if hasattr(op, "name"):
-                key = typing.cast(str, op.name)
-                if key in self._registered_ops:
-                    raise ValueError(f"{key} is already registered")
-            else:
-                raise ValueError(f"The operator must have a 'name' attribute. Got {op}")
+            key = op if isinstance(op, type) else type(op)
+            if key in self._registered_ops:
+                raise ValueError(f"{key} is already registered")
             self._registered_ops[key] = item
             return arg_checker
 

bigframes/core/compile/sqlglot/aggregations/unary_compiler.py

@@ -38,6 +38,26 @@ def compile(
     return UNARY_OP_REGISTRATION[op](op, column, window=window)
 
 
+@UNARY_OP_REGISTRATION.register(agg_ops.ApproxQuartilesOp)
+def _(
+    op: agg_ops.ApproxQuartilesOp,
+    column: typed_expr.TypedExpr,
+    window: typing.Optional[window_spec.WindowSpec] = None,
+) -> sge.Expression:
+    if window is not None:
+        raise NotImplementedError("Approx Quartiles with windowing is not supported.")
+    # APPROX_QUANTILES returns an array of the quartiles, so we need to index it.
+    # The op.quartile is 1-based for the quartile, but array is 0-indexed.
+    # The quartiles are Q0, Q1, Q2, Q3, Q4. op.quartile is 1, 2, or 3.
+    # The array has 5 elements (for N=4 intervals).
+    # So we want the element at index `op.quartile`.
+    approx_quantiles_expr = sge.func("APPROX_QUANTILES", column.expr, sge.convert(4))
+    return sge.Bracket(
+        this=approx_quantiles_expr,
+        expressions=[sge.func("OFFSET", sge.convert(op.quartile))],
+    )
+
+
 @UNARY_OP_REGISTRATION.register(agg_ops.CountOp)
 def _(
     op: agg_ops.CountOp,

tests/unit/core/compile/sqlglot/aggregations/snapshots/test_unary_compiler/test_approx_quartiles/out.sql

@@ -0,0 +1,16 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `int64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    APPROX_QUANTILES(`bfcol_0`, 4)[OFFSET(1)] AS `bfcol_1`,
+    APPROX_QUANTILES(`bfcol_0`, 4)[OFFSET(2)] AS `bfcol_2`,
+    APPROX_QUANTILES(`bfcol_0`, 4)[OFFSET(3)] AS `bfcol_3`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `q1`,
+  `bfcol_2` AS `q2`,
+  `bfcol_3` AS `q3`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/aggregations/test_unary_compiler.py

@@ -38,6 +38,21 @@ def _apply_unary_agg_ops(
     return sql
 
 
+def test_approx_quartiles(scalar_types_df: bpd.DataFrame, snapshot):
+    col_name = "int64_col"
+    bf_df = scalar_types_df[[col_name]]
+    agg_ops_map = {
+        "q1": agg_ops.ApproxQuartilesOp(quartile=1).as_expr(col_name),
+        "q2": agg_ops.ApproxQuartilesOp(quartile=2).as_expr(col_name),
+        "q3": agg_ops.ApproxQuartilesOp(quartile=3).as_expr(col_name),
+    }
+    sql = _apply_unary_agg_ops(
+        bf_df, list(agg_ops_map.values()), list(agg_ops_map.keys())
+    )
+
+    snapshot.assert_match(sql, "out.sql")
+
+
 def test_count(scalar_types_df: bpd.DataFrame, snapshot):
     col_name = "int64_col"
     bf_df = scalar_types_df[[col_name]]