refactor: replace internal error message variable with a public constant

- Updated the error message variable for type errors in expressions to a public constant `EXPR_TYPE_ERROR` for better readability and maintainability.
- Adjusted usage of the error message in various methods within the `DataFrame` class to reflect the change.

Author: kosiew

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 not isinstance(p, Expr):
-                raise TypeError(_EXPR_TYPE_ERROR)
-            df = df.filter(p.expr)
+            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])
         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,20 +478,19 @@ def _simplify_expression(
         ) -> list[expr_internal.Expr]:
             expr_list: list[expr_internal.Expr] = []
             for expr in exprs:
-                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)
+                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)
             return expr_list
 
         expressions = _simplify_expression(*exprs, **named_exprs)
@@ -536,7 +535,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))
 
@@ -552,7 +551,20 @@ def sort(self, *exprs: Expr | SortExpr | str) -> DataFrame:
         Returns:
             DataFrame after sorting.
         """
-        exprs_raw = sort_list_to_raw_sort_list(list(exprs))
+        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)
         return DataFrame(self.df.sort(*exprs_raw))
 
     def cast(self, mapping: dict[str, pa.DataType[Any]]) -> DataFrame:
@@ -779,7 +791,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,6 +130,7 @@
 WindowExpr = expr_internal.WindowExpr
 
 __all__ = [
+    "EXPR_TYPE_ERROR",
     "Aggregate",
     "AggregateFunction",
     "Alias",
@@ -236,7 +237,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