Revert to last good commit

Author: kosiew

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

@@ -142,21 +142,21 @@ For such methods, you can pass column names directly:
 
 .. code-block:: python
 
-    from datafusion import col, functions as f
+    from datafusion import col, column, functions as f
 
     df.sort('id')
     df.aggregate('id', [f.count(col('value'))])
 
-The same operation can also be written with explicit column expressions, using either ``col()`` or ``column()``:
+The same operation can also be written with an explicit column expression:
 
 .. code-block:: python
 
     from datafusion import col, column, functions as f
 
     df.sort(col('id'))
-    df.aggregate(column('id'), [f.count(col('value'))])
+    df.aggregate(col('id'), [f.count(col('value'))])
 
-Note that ``column()`` is an alias of ``col()``, so you can use either name; the example above shows both in action.
+Note that ``column()`` is an alias of ``col()``, so you can use either name.
 
 Whenever an argument represents an expression—such as in
 :py:meth:`~datafusion.DataFrame.filter` or

python/datafusion/dataframe.py

@@ -41,7 +41,7 @@
 from datafusion._internal import ParquetColumnOptions as ParquetColumnOptionsInternal
 from datafusion._internal import ParquetWriterOptions as ParquetWriterOptionsInternal
 from datafusion.expr import (
-    EXPR_TYPE_ERROR,
+    _EXPR_TYPE_ERROR,
     Expr,
     SortExpr,
     expr_list_to_raw_expr_list,
@@ -430,9 +430,9 @@ def filter(self, *predicates: Expr) -> DataFrame:
         """
         df = self.df
         for p in predicates:
-            if isinstance(p, str) or not isinstance(p, Expr):
-                raise TypeError(EXPR_TYPE_ERROR)
-            df = df.filter(expr_list_to_raw_expr_list(p)[0])
+            if not isinstance(p, Expr):
+                raise TypeError(_EXPR_TYPE_ERROR)
+            df = df.filter(p.expr)
         return DataFrame(df)
 
     def with_column(self, name: str, expr: Expr) -> DataFrame:
@@ -446,7 +446,7 @@ def with_column(self, name: str, expr: Expr) -> DataFrame:
             DataFrame with the new column.
         """
         if not isinstance(expr, Expr):
-            raise TypeError(EXPR_TYPE_ERROR)
+            raise TypeError(_EXPR_TYPE_ERROR)
         return DataFrame(self.df.with_column(name, expr.expr))
 
     def with_columns(
@@ -478,19 +478,20 @@ def _simplify_expression(
         ) -> list[expr_internal.Expr]:
             expr_list: list[expr_internal.Expr] = []
             for expr in exprs:
-                if isinstance(expr, str):
-                    raise TypeError(EXPR_TYPE_ERROR)
-                if isinstance(expr, Iterable) and not isinstance(expr, Expr):
-                    if any(not isinstance(inner_expr, Expr) for inner_expr in expr):
-                        raise TypeError(EXPR_TYPE_ERROR)
-                elif not isinstance(expr, Expr):
-                    raise TypeError(EXPR_TYPE_ERROR)
-                expr_list.extend(expr_list_to_raw_expr_list(expr))
-            if named_exprs:
-                for alias, expr in named_exprs.items():
-                    if not isinstance(expr, Expr):
-                        raise TypeError(EXPR_TYPE_ERROR)
-                    expr_list.append(expr.alias(alias).expr)
+                if isinstance(expr, str) or (
+                    isinstance(expr, Iterable)
+                    and not isinstance(expr, Expr)
+                    and any(isinstance(inner, str) for inner in expr)
+                ):
+                    raise TypeError(_EXPR_TYPE_ERROR)
+                try:
+                    expr_list.extend(expr_list_to_raw_expr_list(expr))
+                except TypeError as err:
+                    raise TypeError(_EXPR_TYPE_ERROR) from err
+            for alias, expr in named_exprs.items():
+                if not isinstance(expr, Expr):
+                    raise TypeError(_EXPR_TYPE_ERROR)
+                expr_list.append(expr.alias(alias).expr)
             return expr_list
 
         expressions = _simplify_expression(*exprs, **named_exprs)
@@ -535,7 +536,7 @@ def aggregate(
         aggs_exprs = []
         for agg in aggs_list:
             if not isinstance(agg, Expr):
-                raise TypeError(EXPR_TYPE_ERROR)
+                raise TypeError(_EXPR_TYPE_ERROR)
             aggs_exprs.append(agg.expr)
         return DataFrame(self.df.aggregate(group_by_exprs, aggs_exprs))
 
@@ -551,20 +552,7 @@ def sort(self, *exprs: Expr | SortExpr | str) -> DataFrame:
         Returns:
             DataFrame after sorting.
         """
-        exprs_raw = []
-        for e in exprs:
-            if isinstance(e, SortExpr):
-                exprs_raw.append(sort_or_default(e))
-            elif isinstance(e, str):
-                exprs_raw.append(sort_or_default(Expr.column(e)))
-            elif isinstance(e, Expr):
-                exprs_raw.append(sort_or_default(e))
-            else:
-                error = (
-                    "Expected Expr or column name, found:"
-                    f" {type(e).__name__}. {EXPR_TYPE_ERROR}."
-                )
-                raise TypeError(error)
+        exprs_raw = sort_list_to_raw_sort_list(list(exprs))
         return DataFrame(self.df.sort(*exprs_raw))
 
     def cast(self, mapping: dict[str, pa.DataType[Any]]) -> DataFrame:
@@ -791,7 +779,7 @@ def join_on(
         exprs = []
         for expr in on_exprs:
             if not isinstance(expr, Expr):
-                raise TypeError(EXPR_TYPE_ERROR)
+                raise TypeError(_EXPR_TYPE_ERROR)
             exprs.append(expr.expr)
         return DataFrame(self.df.join_on(right.df, exprs, how))
 

python/datafusion/expr.py

@@ -41,7 +41,7 @@
 
 
 # Standard error message for invalid expression types
-EXPR_TYPE_ERROR = "Use col() or lit() to construct expressions"
+_EXPR_TYPE_ERROR = "Use col() or lit() to construct expressions"
 
 # The following are imported from the internal representation. We may choose to
 # give these all proper wrappers, or to simply leave as is. These were added
@@ -130,7 +130,6 @@
 WindowExpr = expr_internal.WindowExpr
 
 __all__ = [
-    "EXPR_TYPE_ERROR",
     "Aggregate",
     "AggregateFunction",
     "Alias",
@@ -237,7 +236,7 @@ def expr_list_to_raw_expr_list(
         else:
             error = (
                 "Expected Expr or column name, found:"
-                f" {type(e).__name__}. {EXPR_TYPE_ERROR}."
+                f" {type(e).__name__}. {_EXPR_TYPE_ERROR}."
             )
             raise TypeError(error)
     return raw_exprs