UNPICK

Author: kosiew

docs/source/user-guide/dataframe/index.rst

@@ -126,49 +126,6 @@ DataFusion's DataFrame API offers a wide range of operations:
     # Drop columns
     df = df.drop("temporary_column")
 
-String Columns and Expressions
-------------------------------
-
-Some ``DataFrame`` methods accept plain strings when an argument refers to an
-existing column. These include:
-
-* :py:meth:`~datafusion.DataFrame.select`
-* :py:meth:`~datafusion.DataFrame.sort`
-* :py:meth:`~datafusion.DataFrame.drop`
-* :py:meth:`~datafusion.DataFrame.join` (``on`` argument)
-* :py:meth:`~datafusion.DataFrame.aggregate` (grouping columns)
-
-For such methods, you can pass column names directly:
-
-.. code-block:: python
-
-    from datafusion import col, functions as f
-
-    df.sort('id')
-    df.aggregate('id', [f.count(col('value'))])
-
-The same operation can also be written with an explicit column expression:
-
-.. code-block:: python
-
-    from datafusion import col, functions as f
-
-    df.sort(col('id'))
-    df.aggregate(col('id'), [f.count(col('value'))])
-
-Whenever an argument represents an expression—such as in
-:py:meth:`~datafusion.DataFrame.filter` or
-:py:meth:`~datafusion.DataFrame.with_column`—use ``col()`` to reference columns
-and wrap constant values with ``lit()`` (also available as ``literal()``):
-
-.. code-block:: python
-
-    from datafusion import col, lit
-    df.filter(col('age') > lit(21))
-
-Without ``lit()`` DataFusion would treat ``21`` as a column name rather than a
-constant value.
-
 Terminal Operations
 -------------------
 

python/datafusion/dataframe.py

@@ -40,7 +40,7 @@
 from datafusion._internal import DataFrame as DataFrameInternal
 from datafusion._internal import ParquetColumnOptions as ParquetColumnOptionsInternal
 from datafusion._internal import ParquetWriterOptions as ParquetWriterOptionsInternal
-from datafusion.expr import Expr, SortExpr, expr_list_to_raw_expr_list, sort_or_default
+from datafusion.expr import Expr, SortExpr, sort_or_default
 from datafusion.plan import ExecutionPlan, LogicalPlan
 from datafusion.record_batch import RecordBatchStream
 
@@ -394,7 +394,9 @@ def select(self, *exprs: Expr | str) -> DataFrame:
             df = df.select("a", col("b"), col("a").alias("alternate_a"))
 
         """
-        exprs_internal = expr_list_to_raw_expr_list(exprs)
+        exprs_internal = [
+            Expr.column(arg).expr if isinstance(arg, str) else arg.expr for arg in exprs
+        ]
         return DataFrame(self.df.select(*exprs_internal))
 
     def drop(self, *columns: str) -> DataFrame:
@@ -424,10 +426,7 @@ def filter(self, *predicates: Expr) -> DataFrame:
         """
         df = self.df
         for p in predicates:
-            if isinstance(p, str) or not isinstance(p, Expr):
-                error = "Use col() or lit() to construct expressions"
-                raise TypeError(error)
-            df = df.filter(expr_list_to_raw_expr_list(p)[0])
+            df = df.filter(p.expr)
         return DataFrame(df)
 
     def with_column(self, name: str, expr: Expr) -> DataFrame:
@@ -440,9 +439,6 @@ def with_column(self, name: str, expr: Expr) -> DataFrame:
         Returns:
             DataFrame with the new column.
         """
-        if not isinstance(expr, Expr):
-            error = "Use col() or lit() to construct expressions"
-            raise TypeError(error)
         return DataFrame(self.df.with_column(name, expr.expr))
 
     def with_columns(
@@ -476,20 +472,12 @@ def _simplify_expression(
             for expr in exprs:
                 if isinstance(expr, Expr):
                     expr_list.append(expr.expr)
-                elif isinstance(expr, Iterable) and not isinstance(expr, (str, Expr)):
-                    for inner_expr in expr:
-                        if not isinstance(inner_expr, Expr):
-                            error = "Use col() or lit() to construct expressions"
-                            raise TypeError(error)
-                        expr_list.append(inner_expr.expr)
+                elif isinstance(expr, Iterable):
+                    expr_list.extend(inner_expr.expr for inner_expr in expr)
                 else:
-                    error = "Use col() or lit() to construct expressions"
-                    raise TypeError(error)
+                    raise NotImplementedError
             if named_exprs:
                 for alias, expr in named_exprs.items():
-                    if not isinstance(expr, Expr):
-                        error = "Use col() or lit() to construct expressions"
-                        raise TypeError(error)
                     expr_list.append(expr.alias(alias).expr)
             return expr_list
 
@@ -515,62 +503,37 @@ def with_column_renamed(self, old_name: str, new_name: str) -> DataFrame:
         return DataFrame(self.df.with_column_renamed(old_name, new_name))
 
     def aggregate(
-        self,
-        group_by: list[Expr | str] | Expr | str,
-        aggs: list[Expr] | Expr,
+        self, group_by: list[Expr] | Expr, aggs: list[Expr] | Expr
     ) -> DataFrame:
         """Aggregates the rows of the current DataFrame.
 
         Args:
-            group_by: List of expressions or column names to group by.
+            group_by: List of expressions to group by.
             aggs: List of expressions to aggregate.
 
         Returns:
             DataFrame after aggregation.
         """
-        group_by_list = group_by if isinstance(group_by, list) else [group_by]
-        aggs_list = aggs if isinstance(aggs, list) else [aggs]
-
-        group_by_exprs = []
-        for e in group_by_list:
-            if isinstance(e, str):
-                group_by_exprs.append(Expr.column(e).expr)
-            elif isinstance(e, Expr):
-                group_by_exprs.append(e.expr)
-            else:
-                error = (
-                    "Expected Expr or column name, found:"
-                    f" {type(e).__name__}. Use col() or lit() to construct expressions"
-                )
-                raise TypeError(error)
-        aggs_exprs = []
-        for agg in aggs_list:
-            if not isinstance(agg, Expr):
-                error = "Use col() or lit() to construct expressions"
-                raise TypeError(error)
-            aggs_exprs.append(agg.expr)
-        return DataFrame(self.df.aggregate(group_by_exprs, aggs_exprs))
-
-    def sort(self, *exprs: Expr | SortExpr | str) -> DataFrame:
-        """Sort the DataFrame by the specified sorting expressions or column names.
+        group_by = group_by if isinstance(group_by, list) else [group_by]
+        aggs = aggs if isinstance(aggs, list) else [aggs]
+
+        group_by = [e.expr for e in group_by]
+        aggs = [e.expr for e in aggs]
+        return DataFrame(self.df.aggregate(group_by, aggs))
+
+    def sort(self, *exprs: Expr | SortExpr) -> DataFrame:
+        """Sort the DataFrame by the specified sorting expressions.
 
         Note that any expression can be turned into a sort expression by
-        calling its ``sort`` method.
+        calling its` ``sort`` method.
 
         Args:
-            exprs: Sort expressions or column names, applied in order.
+            exprs: Sort expressions, applied in order.
 
         Returns:
             DataFrame after sorting.
         """
-        expr_seq = [e for e in exprs if not isinstance(e, SortExpr)]
-        raw_exprs_iter = iter(expr_list_to_raw_expr_list(expr_seq))
-        exprs_raw = []
-        for e in exprs:
-            if isinstance(e, SortExpr):
-                exprs_raw.append(sort_or_default(e))
-            else:
-                exprs_raw.append(sort_or_default(Expr(next(raw_exprs_iter))))
+        exprs_raw = [sort_or_default(expr) for expr in exprs]
         return DataFrame(self.df.sort(*exprs_raw))
 
     def cast(self, mapping: dict[str, pa.DataType[Any]]) -> DataFrame:
@@ -794,12 +757,7 @@ def join_on(
         Returns:
             DataFrame after join.
         """
-        exprs = []
-        for expr in on_exprs:
-            if not isinstance(expr, Expr):
-                error = "Use col() or lit() to construct expressions"
-                raise TypeError(error)
-            exprs.append(expr.expr)
+        exprs = [expr.expr for expr in on_exprs]
         return DataFrame(self.df.join_on(right.df, exprs, how))
 
     def explain(self, verbose: bool = False, analyze: bool = False) -> None:

python/datafusion/expr.py

@@ -22,7 +22,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Sequence
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
 import pyarrow as pa
 
@@ -216,26 +216,12 @@
 
 
 def expr_list_to_raw_expr_list(
-    expr_list: Optional[Sequence[Expr | str] | Expr | str],
+    expr_list: Optional[list[Expr] | Expr],
 ) -> Optional[list[expr_internal.Expr]]:
-    """Convert a sequence of expressions or column names to raw expressions."""
-    if isinstance(expr_list, (Expr, str)):
+    """Helper function to convert an optional list to raw expressions."""
+    if isinstance(expr_list, Expr):
         expr_list = [expr_list]
-    if expr_list is None:
-        return None
-    raw_exprs: list[expr_internal.Expr] = []
-    for e in expr_list:
-        if isinstance(e, str):
-            raw_exprs.append(Expr.column(e).expr)
-        elif isinstance(e, Expr):
-            raw_exprs.append(e.expr)
-        else:
-            error = (
-                "Expected Expr or column name, found:"
-                f" {type(e).__name__}. Use col() or lit() to construct expressions."
-            )
-            raise TypeError(error)
-    return raw_exprs
+    return [e.expr for e in expr_list] if expr_list is not None else None
 
 
 def sort_or_default(e: Expr | SortExpr) -> expr_internal.SortExpr:

python/tests/test_dataframe.py

@@ -227,13 +227,6 @@ def test_select_mixed_expr_string(df):
     assert result.column(1) == pa.array([1, 2, 3])
 
 
-def test_select_unsupported(df):
-    with pytest.raises(
-        TypeError, match=r"Expected Expr or column name.*col\(\) or lit\(\)"
-    ):
-        df.select(1)
-
-
 def test_filter(df):
     df1 = df.filter(column("a") > literal(2)).select(
         column("a") + column("b"),
@@ -275,34 +268,6 @@ def test_sort(df):
     assert table.to_pydict() == expected
 
 
-def test_sort_string_and_expression_equivalent(df):
-    from datafusion import col
-
-    result_str = df.sort("a").to_pydict()
-    result_expr = df.sort(col("a")).to_pydict()
-    assert result_str == result_expr
-
-
-def test_sort_unsupported(df):
-    with pytest.raises(
-        TypeError, match=r"Expected Expr or column name.*col\(\) or lit\(\)"
-    ):
-        df.sort(1)
-
-
-def test_aggregate_string_and_expression_equivalent(df):
-    from datafusion import col
-
-    result_str = df.aggregate("a", [f.count()]).to_pydict()
-    result_expr = df.aggregate(col("a"), [f.count()]).to_pydict()
-    assert result_str == result_expr
-
-
-def test_filter_string_unsupported(df):
-    with pytest.raises(TypeError, match=r"col\(\) or lit\(\)"):
-        df.filter("a > 1")
-
-
 def test_drop(df):
     df = df.drop("c")
 
@@ -372,11 +337,6 @@ def test_with_column(df):
     assert result.column(2) == pa.array([5, 7, 9])
 
 
-def test_with_column_invalid_expr(df):
-    with pytest.raises(TypeError, match=r"Use col\(\) or lit\(\)"):
-        df.with_column("c", "a")
-
-
 def test_with_columns(df):
     df = df.with_columns(
         (column("a") + column("b")).alias("c"),
@@ -408,13 +368,6 @@ def test_with_columns(df):
     assert result.column(6) == pa.array([5, 7, 9])
 
 
-def test_with_columns_invalid_expr(df):
-    with pytest.raises(TypeError, match=r"Use col\(\) or lit\(\)"):
-        df.with_columns("a")
-    with pytest.raises(TypeError, match=r"Use col\(\) or lit\(\)"):
-        df.with_columns(c="a")
-
-
 def test_cast(df):
     df = df.cast({"a": pa.float16(), "b": pa.list_(pa.uint32())})
     expected = pa.schema(
@@ -573,25 +526,6 @@ def test_join_on():
     assert table.to_pydict() == expected
 
 
-def test_join_on_invalid_expr():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2]), pa.array([4, 5])],
-        names=["a", "b"],
-    )
-    df = ctx.create_dataframe([[batch]], "l")
-    df1 = ctx.create_dataframe([[batch]], "r")
-
-    with pytest.raises(TypeError, match=r"Use col\(\) or lit\(\)"):
-        df.join_on(df1, "a")
-
-
-def test_aggregate_invalid_aggs(df):
-    with pytest.raises(TypeError, match=r"Use col\(\) or lit\(\)"):
-        df.aggregate([], "a")
-
-
 def test_distinct():
     ctx = SessionContext()