sqlspec 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

sqlspec/statement/builder/__init__.py

@@ -8,47 +8,57 @@ parameter binding and validation.
 
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.statement.builder.base import QueryBuilder, SafeQuery
+from sqlspec.statement.builder.column import Column, ColumnExpression, FunctionColumn
 from sqlspec.statement.builder.ddl import (
-    AlterTableBuilder,
-    CreateIndexBuilder,
-    CreateMaterializedViewBuilder,
-    CreateSchemaBuilder,
-    CreateTableAsSelectBuilder,
-    CreateViewBuilder,
+    AlterTable,
+    CommentOn,
+    CreateIndex,
+    CreateMaterializedView,
+    CreateSchema,
+    CreateTable,
+    CreateTableAsSelect,
+    CreateView,
     DDLBuilder,
-    DropIndexBuilder,
-    DropSchemaBuilder,
-    DropTableBuilder,
-    DropViewBuilder,
-    TruncateTableBuilder,
+    DropIndex,
+    DropSchema,
+    DropTable,
+    DropView,
+    RenameTable,
+    TruncateTable,
 )
-from sqlspec.statement.builder.delete import DeleteBuilder
-from sqlspec.statement.builder.insert import InsertBuilder
-from sqlspec.statement.builder.merge import MergeBuilder
+from sqlspec.statement.builder.delete import Delete
+from sqlspec.statement.builder.insert import Insert
+from sqlspec.statement.builder.merge import Merge
 from sqlspec.statement.builder.mixins import WhereClauseMixin
-from sqlspec.statement.builder.select import SelectBuilder
-from sqlspec.statement.builder.update import UpdateBuilder
+from sqlspec.statement.builder.select import Select
+from sqlspec.statement.builder.update import Update
 
 __all__ = (
-    "AlterTableBuilder",
-    "CreateIndexBuilder",
-    "CreateMaterializedViewBuilder",
-    "CreateSchemaBuilder",
-    "CreateTableAsSelectBuilder",
-    "CreateViewBuilder",
+    "AlterTable",
+    "Column",
+    "ColumnExpression",
+    "CommentOn",
+    "CreateIndex",
+    "CreateMaterializedView",
+    "CreateSchema",
+    "CreateTable",
+    "CreateTableAsSelect",
+    "CreateView",
     "DDLBuilder",
-    "DeleteBuilder",
-    "DropIndexBuilder",
-    "DropSchemaBuilder",
-    "DropTableBuilder",
-    "DropViewBuilder",
-    "InsertBuilder",
-    "MergeBuilder",
+    "Delete",
+    "DropIndex",
+    "DropSchema",
+    "DropTable",
+    "DropView",
+    "FunctionColumn",
+    "Insert",
+    "Merge",
     "QueryBuilder",
+    "RenameTable",
     "SQLBuilderError",
     "SafeQuery",
-    "SelectBuilder",
-    "TruncateTableBuilder",
-    "UpdateBuilder",
+    "Select",
+    "TruncateTable",
+    "Update",
     "WhereClauseMixin",
 )

sqlspec/statement/builder/_ddl_utils.py

@@ -12,10 +12,8 @@ __all__ = ("build_column_expression", "build_constraint_expression")
 
 def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
     """Build SQLGlot expression for a column definition."""
-    # Start with column name and type
     col_def = exp.ColumnDef(this=exp.to_identifier(col.name), kind=exp.DataType.build(col.dtype))
 
-    # Add constraints
     constraints: list[exp.ColumnConstraint] = []
 
     if col.not_null:
@@ -28,10 +26,8 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
         constraints.append(exp.ColumnConstraint(kind=exp.UniqueColumnConstraint()))
 
     if col.default is not None:
-        # Handle different default value types
         default_expr: Optional[exp.Expression] = None
         if isinstance(col.default, str):
-            # Check if it's a function/expression or a literal string
             if col.default.upper() in {"CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME"} or "(" in col.default:
                 default_expr = exp.maybe_parse(col.default)
             else:
@@ -55,14 +51,12 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
         constraints.append(exp.ColumnConstraint(kind=exp.CommentColumnConstraint(this=exp.Literal.string(col.comment))))
 
     if col.generated:
-        # Handle generated columns (computed columns)
         generated_expr = exp.GeneratedAsIdentityColumnConstraint(this=exp.maybe_parse(col.generated))
         constraints.append(exp.ColumnConstraint(kind=generated_expr))
 
     if col.collate:
         constraints.append(exp.ColumnConstraint(kind=exp.CollateColumnConstraint(this=exp.to_identifier(col.collate))))
 
-    # Set constraints on column definition
     if constraints:
         col_def.set("constraints", constraints)
 
@@ -72,7 +66,6 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
 def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional[exp.Expression]":
     """Build SQLGlot expression for a table constraint."""
     if constraint.constraint_type == "PRIMARY KEY":
-        # Build primary key constraint
         pk_cols = [exp.to_identifier(col) for col in constraint.columns]
         pk_constraint = exp.PrimaryKey(expressions=pk_cols)
 
@@ -81,7 +74,6 @@ def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional
         return pk_constraint
 
     if constraint.constraint_type == "FOREIGN KEY":
-        # Build foreign key constraint
         fk_cols = [exp.to_identifier(col) for col in constraint.columns]
         ref_cols = [exp.to_identifier(col) for col in constraint.references_columns]
 
@@ -100,7 +92,6 @@ def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional
         return fk_constraint
 
     if constraint.constraint_type == "UNIQUE":
-        # Build unique constraint
         unique_cols = [exp.to_identifier(col) for col in constraint.columns]
         unique_constraint = exp.UniqueKeyProperty(expressions=unique_cols)
 
@@ -109,7 +100,6 @@ def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional
         return unique_constraint
 
     if constraint.constraint_type == "CHECK":
-        # Build check constraint
         check_expr = exp.Check(this=exp.maybe_parse(constraint.condition) if constraint.condition else None)
 
         if constraint.name:

sqlspec/statement/builder/_parsing_utils.py

@@ -10,7 +10,7 @@ from typing import Any, Optional, Union, cast
 from sqlglot import exp, maybe_parse, parse_one
 
 
-def parse_column_expression(column_input: Union[str, exp.Expression]) -> exp.Expression:
+def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> exp.Expression:
     """Parse a column input that might be a complex expression.
 
     Handles cases like:
@@ -19,15 +19,23 @@ def parse_column_expression(column_input: Union[str, exp.Expression]) -> exp.Exp
     - Aliased columns: "name AS user_name" -> Alias(this=Column(name), alias=user_name)
     - Function calls: "MAX(price)" -> Max(this=Column(price))
     - Complex expressions: "CASE WHEN ... END" -> Case(...)
+    - Custom Column objects from our builder
 
     Args:
-        column_input: String or SQLGlot expression representing a column/expression
+        column_input: String, SQLGlot expression, or Column object
 
     Returns:
         exp.Expression: Parsed SQLGlot expression
     """
     if isinstance(column_input, exp.Expression):
         return column_input
+
+    # Handle our custom Column objects
+    if hasattr(column_input, "_expr"):
+        attr_value = getattr(column_input, "_expr", None)
+        if isinstance(attr_value, exp.Expression):
+            return attr_value
+
     return exp.maybe_parse(column_input) or exp.column(str(column_input))
 
 
@@ -96,7 +104,6 @@ def parse_condition_expression(
 
     tuple_condition_parts = 2
     if isinstance(condition_input, tuple) and len(condition_input) == tuple_condition_parts:
-        # Handle (column, value) tuple format with proper parameter binding
         column, value = condition_input
         column_expr = parse_column_expression(column)
         if value is None:
@@ -105,7 +112,6 @@ def parse_condition_expression(
         if builder and hasattr(builder, "add_parameter"):
             _, param_name = builder.add_parameter(value)
             return exp.EQ(this=column_expr, expression=exp.Placeholder(this=param_name))
-        # Fallback to literal value
         if isinstance(value, str):
             return exp.EQ(this=column_expr, expression=exp.Literal.string(value))
         if isinstance(value, (int, float)):

sqlspec/statement/builder/base.py

@@ -7,7 +7,7 @@ advanced builder patterns and optimization capabilities.
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generic, NoReturn, Optional, Union
+from typing import TYPE_CHECKING, Any, Generic, NoReturn, Optional, Union, cast
 
 import sqlglot
 from sqlglot import Dialect, exp
@@ -20,6 +20,7 @@ from sqlspec.exceptions import SQLBuilderError
 from sqlspec.statement.sql import SQL, SQLConfig
 from sqlspec.typing import RowT
 from sqlspec.utils.logging import get_logger
+from sqlspec.utils.type_guards import has_sql_method, has_with_method
 
 if TYPE_CHECKING:
     from sqlspec.statement.result import SQLResult
@@ -124,6 +125,32 @@ class QueryBuilder(ABC, Generic[RowT]):
         self._parameters[param_name] = value
         return param_name
 
+    def _parameterize_expression(self, expression: exp.Expression) -> exp.Expression:
+        """Replace literal values in an expression with bound parameters.
+
+        This method traverses a SQLGlot expression tree and replaces literal
+        values with parameter placeholders, adding the values to the builder's
+        parameter collection.
+
+        Args:
+            expression: The SQLGlot expression to parameterize
+
+        Returns:
+            A new expression with literals replaced by parameter placeholders
+        """
+
+        def replacer(node: exp.Expression) -> exp.Expression:
+            if isinstance(node, exp.Literal):
+                # Skip boolean literals (TRUE/FALSE) and NULL
+                if node.this in (True, False, None):
+                    return node
+                # Convert other literals to parameters
+                param_name = self._add_parameter(node.this, context="where")
+                return exp.Placeholder(this=param_name)
+            return node
+
+        return expression.transform(replacer, copy=True)
+
     def add_parameter(self: Self, value: Any, name: Optional[str] = None) -> tuple[Self, str]:
         """Explicitly adds a parameter to the query.
 
@@ -191,7 +218,7 @@ class QueryBuilder(ABC, Generic[RowT]):
                 msg = f"CTE query builder expression must be a Select, got {type(query._expression).__name__}."
                 self._raise_sql_builder_error(msg)
             cte_select_expression = query._expression.copy()
-            for p_name, p_value in query._parameters.items():
+            for p_name, p_value in query.parameters.items():
                 # Try to preserve original parameter name, only rename if collision
                 unique_name = self._generate_unique_parameter_name(p_name)
                 self.add_parameter(p_value, unique_name)
@@ -231,23 +258,21 @@ class QueryBuilder(ABC, Generic[RowT]):
         final_expression = self._expression.copy()
 
         if self._with_ctes:
-            if hasattr(final_expression, "with_") and callable(getattr(final_expression, "with_", None)):
+            if has_with_method(final_expression):
+                # Type checker now knows final_expression has with_ method
                 for alias, cte_node in self._with_ctes.items():
-                    final_expression = final_expression.with_(  # pyright: ignore
-                        cte_node.args["this"], as_=alias, copy=False
-                    )
-            elif (
-                isinstance(final_expression, (exp.Select, exp.Insert, exp.Update, exp.Delete, exp.Union))
-                and self._with_ctes
-            ):
+                    final_expression = cast("Any", final_expression).with_(cte_node.args["this"], as_=alias, copy=False)
+            elif isinstance(final_expression, (exp.Select, exp.Insert, exp.Update, exp.Delete, exp.Union)):
                 final_expression = exp.With(expressions=list(self._with_ctes.values()), this=final_expression)
 
-        # Apply SQLGlot optimizations if enabled
-        if self.enable_optimization:
+        if self.enable_optimization and isinstance(final_expression, exp.Expression):
             final_expression = self._optimize_expression(final_expression)
 
         try:
-            sql_string = final_expression.sql(dialect=self.dialect_name, pretty=True)
+            if has_sql_method(final_expression):
+                sql_string = final_expression.sql(dialect=self.dialect_name, pretty=True)  # pyright: ignore[reportAttributeAccessIssue]
+            else:
+                sql_string = str(final_expression)
         except Exception as e:
             err_msg = f"Error generating SQL from expression: {e!s}"
             logger.exception("SQL generation failed")
@@ -294,13 +319,30 @@ class QueryBuilder(ABC, Generic[RowT]):
         """
         safe_query = self.build()
 
-        return SQL(
-            statement=safe_query.sql,
-            parameters=safe_query.parameters,
-            _dialect=safe_query.dialect,
-            _config=config,
-            _builder_result_type=self._expected_result_type,
-        )
+        if isinstance(safe_query.parameters, dict):
+            kwargs = safe_query.parameters
+            parameters = None
+        else:
+            kwargs = None
+            parameters = (
+                safe_query.parameters
+                if isinstance(safe_query.parameters, tuple)
+                else tuple(safe_query.parameters)
+                if safe_query.parameters
+                else None
+            )
+
+        if config is None:
+            from sqlspec.statement.sql import SQLConfig
+
+            config = SQLConfig(dialect=safe_query.dialect)
+
+        # SQL expects parameters as variadic args, not as a keyword
+        if kwargs:
+            return SQL(safe_query.sql, config=config, **kwargs)
+        if parameters:
+            return SQL(safe_query.sql, *parameters, config=config)
+        return SQL(safe_query.sql, config=config)
 
     def __str__(self) -> str:
         """Return the SQL string representation of the query.
@@ -311,7 +353,6 @@ class QueryBuilder(ABC, Generic[RowT]):
         try:
             return self.build().sql
         except Exception:
-            # Fallback to default representation if build fails
             return super().__str__()
 
     @property
@@ -324,7 +365,11 @@ class QueryBuilder(ABC, Generic[RowT]):
                 return self.dialect.__name__.lower()
             if isinstance(self.dialect, Dialect):
                 return type(self.dialect).__name__.lower()
-            # Handle case where dialect might have a __name__ attribute
             if hasattr(self.dialect, "__name__"):
                 return self.dialect.__name__.lower()
         return None
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        """Public access to query parameters."""
+        return self._parameters

sqlspec/statement/builder/column.py

@@ -0,0 +1,283 @@
+"""Pythonic column expressions for query building.
+
+This module provides Column objects that support native Python operators
+for building SQL conditions with type safety and parameter binding.
+"""
+
+from collections.abc import Iterable
+from typing import Any, Optional
+
+from sqlglot import exp
+
+from sqlspec.utils.type_guards import has_sql_method
+
+__all__ = ("Column", "ColumnExpression", "FunctionColumn")
+
+
+class ColumnExpression:
+    """Base class for column expressions that can be combined with operators."""
+
+    def __init__(self, expression: exp.Expression) -> None:
+        self._expr = expression
+
+    def __and__(self, other: "ColumnExpression") -> "ColumnExpression":
+        """Combine with AND operator (&)."""
+        if not isinstance(other, ColumnExpression):
+            return NotImplemented
+        return ColumnExpression(exp.And(this=self._expr, expression=other._expr))
+
+    def __or__(self, other: "ColumnExpression") -> "ColumnExpression":
+        """Combine with OR operator (|)."""
+        if not isinstance(other, ColumnExpression):
+            return NotImplemented
+        return ColumnExpression(exp.Or(this=self._expr, expression=other._expr))
+
+    def __invert__(self) -> "ColumnExpression":
+        """Apply NOT operator (~)."""
+        return ColumnExpression(exp.Not(this=self._expr))
+
+    def __bool__(self) -> bool:
+        """Prevent accidental use of 'and'/'or' keywords."""
+        msg = (
+            "Cannot use 'and'/'or' operators on ColumnExpression. "
+            "Use '&'/'|' operators instead. "
+            f"Expression: {self._expr.sql()}"
+        )
+        raise TypeError(msg)
+
+    @property
+    def sqlglot_expression(self) -> exp.Expression:
+        """Get the underlying SQLGlot expression."""
+        return self._expr
+
+
+class Column:
+    """Represents a database column with Python operator support."""
+
+    def __init__(self, name: str, table: Optional[str] = None) -> None:
+        self.name = name
+        self.table = table
+
+        # Create SQLGlot column expression
+        if table:
+            self._expr = exp.Column(this=exp.Identifier(this=name), table=exp.Identifier(this=table))
+        else:
+            self._expr = exp.Column(this=exp.Identifier(this=name))
+
+    # Comparison operators
+    def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
+        """Equal to (==)."""
+        if other is None:
+            return ColumnExpression(exp.Is(this=self._expr, expression=exp.Null()))
+        return ColumnExpression(exp.EQ(this=self._expr, expression=exp.convert(other)))
+
+    def __ne__(self, other: object) -> ColumnExpression:  # type: ignore[override]
+        """Not equal to (!=)."""
+        if other is None:
+            return ColumnExpression(exp.Not(this=exp.Is(this=self._expr, expression=exp.Null())))
+        return ColumnExpression(exp.NEQ(this=self._expr, expression=exp.convert(other)))
+
+    def __gt__(self, other: Any) -> ColumnExpression:
+        """Greater than (>)."""
+        return ColumnExpression(exp.GT(this=self._expr, expression=exp.convert(other)))
+
+    def __ge__(self, other: Any) -> ColumnExpression:
+        """Greater than or equal (>=)."""
+        return ColumnExpression(exp.GTE(this=self._expr, expression=exp.convert(other)))
+
+    def __lt__(self, other: Any) -> ColumnExpression:
+        """Less than (<)."""
+        return ColumnExpression(exp.LT(this=self._expr, expression=exp.convert(other)))
+
+    def __le__(self, other: Any) -> ColumnExpression:
+        """Less than or equal (<=)."""
+        return ColumnExpression(exp.LTE(this=self._expr, expression=exp.convert(other)))
+
+    def __invert__(self) -> ColumnExpression:
+        """Apply NOT operator (~)."""
+        return ColumnExpression(exp.Not(this=self._expr))
+
+    # SQL-specific methods
+    def like(self, pattern: str, escape: Optional[str] = None) -> ColumnExpression:
+        """SQL LIKE pattern matching."""
+        if escape:
+            like_expr = exp.Like(this=self._expr, expression=exp.convert(pattern), escape=exp.convert(escape))
+        else:
+            like_expr = exp.Like(this=self._expr, expression=exp.convert(pattern))
+        return ColumnExpression(like_expr)
+
+    def ilike(self, pattern: str) -> ColumnExpression:
+        """Case-insensitive LIKE."""
+        return ColumnExpression(exp.ILike(this=self._expr, expression=exp.convert(pattern)))
+
+    def in_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL IN clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.In(this=self._expr, expressions=converted_values))
+
+    def not_in(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL NOT IN clause."""
+        return ~self.in_(values)
+
+    def between(self, start: Any, end: Any) -> ColumnExpression:
+        """SQL BETWEEN clause."""
+        return ColumnExpression(exp.Between(this=self._expr, low=exp.convert(start), high=exp.convert(end)))
+
+    def is_null(self) -> ColumnExpression:
+        """SQL IS NULL."""
+        return ColumnExpression(exp.Is(this=self._expr, expression=exp.Null()))
+
+    def is_not_null(self) -> ColumnExpression:
+        """SQL IS NOT NULL."""
+        return ColumnExpression(exp.Not(this=exp.Is(this=self._expr, expression=exp.Null())))
+
+    def not_like(self, pattern: str, escape: Optional[str] = None) -> ColumnExpression:
+        """SQL NOT LIKE pattern matching."""
+        return ~self.like(pattern, escape)
+
+    def not_ilike(self, pattern: str) -> ColumnExpression:
+        """Case-insensitive NOT LIKE."""
+        return ~self.ilike(pattern)
+
+    def any_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL = ANY(...) clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.EQ(this=self._expr, expression=exp.Any(expressions=converted_values)))
+
+    def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL <> ANY(...) clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.NEQ(this=self._expr, expression=exp.Any(expressions=converted_values)))
+
+    # SQL Functions
+    def lower(self) -> "FunctionColumn":
+        """SQL LOWER() function."""
+        return FunctionColumn(exp.Lower(this=self._expr))
+
+    def upper(self) -> "FunctionColumn":
+        """SQL UPPER() function."""
+        return FunctionColumn(exp.Upper(this=self._expr))
+
+    def length(self) -> "FunctionColumn":
+        """SQL LENGTH() function."""
+        return FunctionColumn(exp.Length(this=self._expr))
+
+    def trim(self) -> "FunctionColumn":
+        """SQL TRIM() function."""
+        return FunctionColumn(exp.Trim(this=self._expr))
+
+    def abs(self) -> "FunctionColumn":
+        """SQL ABS() function."""
+        return FunctionColumn(exp.Abs(this=self._expr))
+
+    def round(self, decimals: int = 0) -> "FunctionColumn":
+        """SQL ROUND() function."""
+        if decimals == 0:
+            return FunctionColumn(exp.Round(this=self._expr))
+        return FunctionColumn(exp.Round(this=self._expr, expression=exp.Literal.number(decimals)))
+
+    def floor(self) -> "FunctionColumn":
+        """SQL FLOOR() function."""
+        return FunctionColumn(exp.Floor(this=self._expr))
+
+    def ceil(self) -> "FunctionColumn":
+        """SQL CEIL() function."""
+        return FunctionColumn(exp.Ceil(this=self._expr))
+
+    def substring(self, start: int, length: Optional[int] = None) -> "FunctionColumn":
+        """SQL SUBSTRING() function."""
+        args = [exp.Literal.number(start)]
+        if length is not None:
+            args.append(exp.Literal.number(length))
+        return FunctionColumn(exp.Substring(this=self._expr, expressions=args))
+
+    def coalesce(self, *values: Any) -> "FunctionColumn":
+        """SQL COALESCE() function."""
+        expressions = [self._expr] + [exp.convert(v) for v in values]
+        return FunctionColumn(exp.Coalesce(expressions=expressions))
+
+    def cast(self, data_type: str) -> "FunctionColumn":
+        """SQL CAST() function."""
+        return FunctionColumn(exp.Cast(this=self._expr, to=exp.DataType.build(data_type)))
+
+    def alias(self, alias_name: str) -> exp.Expression:
+        """Create an aliased column expression."""
+        return exp.Alias(this=self._expr, alias=alias_name)
+
+    def __repr__(self) -> str:
+        if self.table:
+            return f"Column<{self.table}.{self.name}>"
+        return f"Column<{self.name}>"
+
+    def __hash__(self) -> int:
+        """Hash based on table and column name."""
+        return hash((self.table, self.name))
+
+
+class FunctionColumn:
+    """Represents the result of a SQL function call on a column."""
+
+    def __init__(self, expression: exp.Expression) -> None:
+        self._expr = expression
+
+    def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
+        return ColumnExpression(exp.EQ(this=self._expr, expression=exp.convert(other)))
+
+    def __ne__(self, other: object) -> ColumnExpression:  # type: ignore[override]
+        return ColumnExpression(exp.NEQ(this=self._expr, expression=exp.convert(other)))
+
+    def like(self, pattern: str) -> ColumnExpression:
+        return ColumnExpression(exp.Like(this=self._expr, expression=exp.convert(pattern)))
+
+    def ilike(self, pattern: str) -> ColumnExpression:
+        """Case-insensitive LIKE."""
+        return ColumnExpression(exp.ILike(this=self._expr, expression=exp.convert(pattern)))
+
+    def in_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL IN clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.In(this=self._expr, expressions=converted_values))
+
+    def not_in_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL NOT IN clause."""
+        return ~self.in_(values)
+
+    def not_like(self, pattern: str) -> ColumnExpression:
+        """SQL NOT LIKE."""
+        return ~self.like(pattern)
+
+    def not_ilike(self, pattern: str) -> ColumnExpression:
+        """Case-insensitive NOT LIKE."""
+        return ~self.ilike(pattern)
+
+    def between(self, start: Any, end: Any) -> ColumnExpression:
+        """SQL BETWEEN clause."""
+        return ColumnExpression(exp.Between(this=self._expr, low=exp.convert(start), high=exp.convert(end)))
+
+    def is_null(self) -> ColumnExpression:
+        """SQL IS NULL."""
+        return ColumnExpression(exp.Is(this=self._expr, expression=exp.Null()))
+
+    def is_not_null(self) -> ColumnExpression:
+        """SQL IS NOT NULL."""
+        return ColumnExpression(exp.Not(this=exp.Is(this=self._expr, expression=exp.Null())))
+
+    def any_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL = ANY(...) clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.EQ(this=self._expr, expression=exp.Any(expressions=converted_values)))
+
+    def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
+        """SQL <> ANY(...) clause."""
+        converted_values = [exp.convert(v) for v in values]
+        return ColumnExpression(exp.NEQ(this=self._expr, expression=exp.Any(expressions=converted_values)))
+
+    def alias(self, alias_name: str) -> exp.Expression:
+        """Create an aliased function expression."""
+        return exp.Alias(this=self._expr, alias=alias_name)
+
+    # Add other operators as needed...
+
+    def __hash__(self) -> int:
+        """Hash based on the SQL expression."""
+        return hash(self._expr.sql() if has_sql_method(self._expr) else str(self._expr))