Address PR review feedback: add quantile_cont alias and simplify examples

- Add quantile_cont as alias for percentile_cont (matches upstream)
- Replace pa.concat_arrays batch pattern with collect_column() in docstrings
- Add percentile_cont, quantile_cont, var_population to docs function list

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: timsaucer

docs/source/user-guide/common-operations/aggregations.rst

@@ -354,6 +354,7 @@ The available aggregate functions are:
     - :py:func:`datafusion.functions.stddev_pop`
     - :py:func:`datafusion.functions.var_samp`
     - :py:func:`datafusion.functions.var_pop`
+    - :py:func:`datafusion.functions.var_population`
 6. Linear Regression Functions
     - :py:func:`datafusion.functions.regr_count`
     - :py:func:`datafusion.functions.regr_slope`
@@ -370,7 +371,9 @@ The available aggregate functions are:
     - :py:func:`datafusion.functions.nth_value`
 8. String Functions
     - :py:func:`datafusion.functions.string_agg`
-9. Approximation Functions
+9. Percentile Functions
+    - :py:func:`datafusion.functions.percentile_cont`
+    - :py:func:`datafusion.functions.quantile_cont`
     - :py:func:`datafusion.functions.approx_distinct`
     - :py:func:`datafusion.functions.approx_median`
     - :py:func:`datafusion.functions.approx_percentile_cont`

python/datafusion/expr.py

@@ -1458,7 +1458,6 @@ def rollup(*exprs: Expr) -> Expr:
             *exprs: Column expressions to include in the rollup.
 
         Examples:
-            >>> import pyarrow as pa
             >>> import datafusion as dfn
             >>> from datafusion.expr import GroupingSet
             >>> ctx = dfn.SessionContext()
@@ -1468,8 +1467,7 @@ def rollup(*exprs: Expr) -> Expr:
             ...     [dfn.functions.sum(dfn.col("b")).alias("s"),
             ...      dfn.functions.grouping(dfn.col("a"))],
             ... ).sort(dfn.col("a").sort(nulls_first=False))
-            >>> batches = result.collect()
-            >>> pa.concat_arrays([b.column("s") for b in batches]).to_pylist()
+            >>> result.collect_column("s").to_pylist()
             [30, 30, 60]
 
         See Also:
@@ -1496,7 +1494,6 @@ def cube(*exprs: Expr) -> Expr:
             With a single column, ``cube`` behaves identically to
             :py:meth:`rollup`:
 
-            >>> import pyarrow as pa
             >>> import datafusion as dfn
             >>> from datafusion.expr import GroupingSet
             >>> ctx = dfn.SessionContext()
@@ -1506,9 +1503,8 @@ def cube(*exprs: Expr) -> Expr:
             ...     [dfn.functions.sum(dfn.col("b")).alias("s"),
             ...      dfn.functions.grouping(dfn.col("a"))],
             ... ).sort(dfn.col("a").sort(nulls_first=False))
-            >>> batches = result.collect()
-            >>> pa.concat_arrays([b.column(2) for b in batches]).to_pylist()
-            [0, 0, 1]
+            >>> result.collect_column("s").to_pylist()
+            [30, 30, 60]
 
         See Also:
             :py:meth:`rollup`, :py:meth:`grouping_sets`,
@@ -1533,7 +1529,6 @@ def grouping_sets(*expr_lists: list[Expr]) -> Expr:
                 expressions forming one grouping set.
 
         Examples:
-            >>> import pyarrow as pa
             >>> import datafusion as dfn
             >>> from datafusion.expr import GroupingSet
             >>> ctx = dfn.SessionContext()
@@ -1550,9 +1545,7 @@ def grouping_sets(*expr_lists: list[Expr]) -> Expr:
             ...     dfn.col("a").sort(nulls_first=False),
             ...     dfn.col("b").sort(nulls_first=False),
             ... )
-            >>> batches = result.collect()
-            >>> pa.concat_arrays(
-            ...     [b.column("s") for b in batches]).to_pylist()
+            >>> result.collect_column("s").to_pylist()
             [3, 3, 4, 2]
 
         See Also:

python/datafusion/functions.py

@@ -261,6 +261,7 @@
     "pi",
     "pow",
     "power",
+    "quantile_cont",
     "radians",
     "random",
     "range",
@@ -4350,6 +4351,19 @@ def percentile_cont(
     return Expr(f.percentile_cont(sort_expr_raw, percentile, filter=filter_raw))
 
 
+def quantile_cont(
+    sort_expression: Expr | SortExpr,
+    percentile: float,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the exact percentile of input values using continuous interpolation.
+
+    See Also:
+        This is an alias for :py:func:`percentile_cont`.
+    """
+    return percentile_cont(sort_expression, percentile, filter)
+
+
 def array_agg(
     expression: Expr,
     distinct: bool = False,
@@ -4449,7 +4463,6 @@ def grouping(
         grand-total row where ``a`` is aggregated across
         (``grouping(a) = 1``):
 
-        >>> import pyarrow as pa
         >>> from datafusion.expr import GroupingSet
         >>> ctx = dfn.SessionContext()
         >>> df = ctx.from_pydict({"a": [1, 1, 2], "b": [10, 20, 30]})
@@ -4458,9 +4471,8 @@ def grouping(
         ...     [dfn.functions.sum(dfn.col("b")).alias("s"),
         ...      dfn.functions.grouping(dfn.col("a"))],
         ... ).sort(dfn.col("a").sort(nulls_first=False))
-        >>> batches = result.collect()
-        >>> pa.concat_arrays([b.column(2) for b in batches]).to_pylist()
-        [0, 0, 1]
+        >>> result.collect_column("s").to_pylist()
+        [30, 30, 60]
 
     See Also:
         :py:class:`~datafusion.expr.GroupingSet`

python/tests/test_functions.py

@@ -1822,18 +1822,19 @@ def test_conditional_functions(df_with_nulls, expr, expected):
 
 
 @pytest.mark.parametrize(
-    ("filter_expr", "expected"),
+    ("func", "filter_expr", "expected"),
     [
-        (None, 3.0),
-        (column("a") > literal(1.0), 3.5),
+        (f.percentile_cont, None, 3.0),
+        (f.percentile_cont, column("a") > literal(1.0), 3.5),
+        (f.quantile_cont, None, 3.0),
     ],
-    ids=["no_filter", "with_filter"],
+    ids=["no_filter", "with_filter", "quantile_cont_alias"],
 )
-def test_percentile_cont(filter_expr, expected):
+def test_percentile_cont(func, filter_expr, expected):
     ctx = SessionContext()
     df = ctx.from_pydict({"a": [1.0, 2.0, 3.0, 4.0, 5.0]})
     result = df.aggregate(
-        [], [f.percentile_cont(column("a"), 0.5, filter=filter_expr).alias("v")]
+        [], [func(column("a"), 0.5, filter=filter_expr).alias("v")]
     ).collect()[0]
     assert result.column(0)[0].as_py() == expected