sqlspec 0.14.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

sqlspec/{statement/builder → builder}/mixins/_pivot_operations.py

@@ -7,7 +7,7 @@ from sqlglot import exp
 if TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
 
-    from sqlspec.statement.builder._select import Select
+    from sqlspec.builder._select import Select
 
 __all__ = ("PivotClauseMixin", "UnpivotClauseMixin")
 
@@ -56,12 +56,10 @@ class PivotClauseMixin:
         for val in pivot_values:
             if isinstance(val, exp.Expression):
                 pivot_value_exprs.append(val)
-            elif isinstance(val, str):
-                pivot_value_exprs.append(exp.Literal.string(val))
-            elif isinstance(val, (int, float)):
-                pivot_value_exprs.append(exp.Literal.number(val))
+            elif isinstance(val, (str, int, float)):
+                pivot_value_exprs.append(exp.convert(val))
             else:
-                pivot_value_exprs.append(exp.Literal.string(str(val)))
+                pivot_value_exprs.append(exp.convert(str(val)))
 
         in_expr = exp.In(this=pivot_col_expr, expressions=pivot_value_exprs)
 
@@ -113,7 +111,6 @@ class UnpivotClauseMixin:
         """
         current_expr = self._expression
         if not isinstance(current_expr, exp.Select):
-            # SelectBuilder's __init__ ensures _expression is exp.Select.
             msg = "Unpivot can only be applied to a Select expression managed by Select."
             raise TypeError(msg)
 
@@ -127,7 +124,6 @@ class UnpivotClauseMixin:
             elif isinstance(col_name_or_expr, str):
                 unpivot_cols_exprs.append(exp.column(col_name_or_expr))
             else:
-                # Fallback for other types, should ideally be an error or more specific handling
                 unpivot_cols_exprs.append(exp.column(str(col_name_or_expr)))
 
         in_expr = exp.In(this=name_col_ident, expressions=unpivot_cols_exprs)

sqlspec/{statement/builder → builder}/mixins/_select_operations.py

@@ -6,15 +6,14 @@ from typing import TYPE_CHECKING, Any, Optional, Union, cast
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import parse_column_expression, parse_table_expression
 from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder._parsing_utils import parse_column_expression, parse_table_expression
 from sqlspec.utils.type_guards import has_query_builder_parameters, is_expression
 
 if TYPE_CHECKING:
+    from sqlspec.builder._base import QueryBuilder
+    from sqlspec.builder._column import Column, FunctionColumn
     from sqlspec.protocols import SelectBuilderProtocol, SQLBuilderProtocol
-    from sqlspec.statement.builder._base import QueryBuilder
-    from sqlspec.statement.builder._column import Column, FunctionColumn
-    from sqlspec.typing import RowT
 
 __all__ = ("CaseBuilder", "SelectClauseMixin")
 
@@ -24,7 +23,6 @@ class SelectClauseMixin:
 
     _expression: Optional[exp.Expression] = None
 
-    # SELECT and DISTINCT methods
     def select(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn"]) -> Self:
         """Add columns to SELECT clause.
 
@@ -69,7 +67,6 @@ class SelectClauseMixin:
             builder._expression.set("distinct", exp.Distinct(expressions=distinct_columns))
         return cast("Self", builder)
 
-    # FROM clause method
     def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Add FROM clause.
 
@@ -93,30 +90,27 @@ class SelectClauseMixin:
         if isinstance(table, str):
             from_expr = parse_table_expression(table, alias)
         elif is_expression(table):
-            # Direct sqlglot expression - use as is
             from_expr = exp.alias_(table, alias) if alias else table
         elif has_query_builder_parameters(table):
-            # Query builder with build() method
             subquery = table.build()
             sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
             subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect", None)))
             from_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
-            current_params = getattr(builder, "_parameters", None)
-            merged_params = getattr(type(builder), "ParameterConverter", None)
-            if merged_params and hasattr(subquery, "parameters"):
-                subquery_params = getattr(subquery, "parameters", {})
-                merged_params = merged_params.merge_parameters(
-                    parameters=subquery_params,
-                    args=current_params if isinstance(current_params, list) else None,
-                    kwargs=current_params if isinstance(current_params, dict) else {},
+            current_parameters = getattr(builder, "_parameters", None)
+            merged_parameters = getattr(type(builder), "ParameterConverter", None)
+            if merged_parameters and hasattr(subquery, "parameters"):
+                subquery_parameters = getattr(subquery, "parameters", {})
+                merged_parameters = merged_parameters.merge_parameters(
+                    parameters=subquery_parameters,
+                    args=current_parameters if isinstance(current_parameters, list) else None,
+                    kwargs=current_parameters if isinstance(current_parameters, dict) else {},
                 )
-                setattr(builder, "_parameters", merged_params)
+                setattr(builder, "_parameters", merged_parameters)
         else:
             from_expr = table
         builder._expression = builder._expression.from_(from_expr, copy=False)
         return cast("Self", builder)
 
-    # GROUP BY methods
     def group_by(self, *columns: Union[str, exp.Expression]) -> Self:
         """Add GROUP BY clause.
 
@@ -149,7 +143,6 @@ class SelectClauseMixin:
 
         Example:
             ```python
-            # GROUP BY ROLLUP(product, region)
             query = (
                 sql.select("product", "region", sql.sum("sales"))
                 .from_("sales_data")
@@ -174,7 +167,6 @@ class SelectClauseMixin:
 
         Example:
             ```python
-            # GROUP BY CUBE(product, region)
             query = (
                 sql.select("product", "region", sql.sum("sales"))
                 .from_("sales_data")
@@ -200,7 +192,6 @@ class SelectClauseMixin:
 
         Example:
             ```python
-            # GROUP BY GROUPING SETS ((product), (region), ())
             query = (
                 sql.select("product", "region", sql.sum("sales"))
                 .from_("sales_data")
@@ -217,13 +208,11 @@ class SelectClauseMixin:
                     columns = [exp.column(col) for col in column_set]
                     set_expressions.append(exp.Tuple(expressions=columns))
             else:
-                # Single column
                 set_expressions.append(exp.column(column_set))
 
         grouping_sets_expr = exp.GroupingSets(expressions=set_expressions)
         return self.group_by(grouping_sets_expr)
 
-    # Aggregate function methods
     def count_(self, column: "Union[str, exp.Expression]" = "*", alias: Optional[str] = None) -> Self:
         """Add COUNT function to SELECT clause.
 
@@ -440,8 +429,7 @@ class SelectClauseMixin:
         """
         builder = cast("SelectBuilderProtocol", self)
         col_expr = exp.column(column) if isinstance(column, str) else column
-        # Use GroupConcat which SQLGlot can translate to STRING_AGG for Postgres
-        string_agg_expr = exp.GroupConcat(this=col_expr, separator=exp.Literal.string(separator))
+        string_agg_expr = exp.GroupConcat(this=col_expr, separator=exp.convert(separator))
         select_expr = exp.alias_(string_agg_expr, alias) if alias else string_agg_expr
         return cast("Self", builder.select(select_expr))
 
@@ -461,7 +449,6 @@ class SelectClauseMixin:
         select_expr = exp.alias_(json_agg_expr, alias) if alias else json_agg_expr
         return cast("Self", builder.select(select_expr))
 
-    # Window function method
     def window(
         self,
         function_expr: Union[str, exp.Expression],
@@ -501,20 +488,19 @@ class SelectClauseMixin:
         else:
             func_expr_parsed = function_expr
 
-        over_args: dict[str, Any] = {}  # Stringified dict
+        over_args: dict[str, Any] = {}
         if partition_by:
             if isinstance(partition_by, str):
                 over_args["partition_by"] = [exp.column(partition_by)]
-            elif isinstance(partition_by, list):  # Check for list
+            elif isinstance(partition_by, list):
                 over_args["partition_by"] = [exp.column(col) if isinstance(col, str) else col for col in partition_by]
-            elif isinstance(partition_by, exp.Expression):  # Check for exp.Expression
+            elif isinstance(partition_by, exp.Expression):
                 over_args["partition_by"] = [partition_by]
 
         if order_by:
             if isinstance(order_by, str):
                 over_args["order"] = exp.column(order_by).asc()
             elif isinstance(order_by, list):
-                # Properly handle multiple ORDER BY columns using Order expression
                 order_expressions: list[Union[exp.Expression, exp.Column]] = []
                 for col in order_by:
                     if isinstance(col, str):
@@ -534,7 +520,6 @@ class SelectClauseMixin:
         self._expression.select(exp.alias_(window_expr, alias) if alias else window_expr, copy=False)
         return self
 
-    # CASE expression method
     def case_(self, alias: "Optional[str]" = None) -> "CaseBuilder":
         """Create a CASE expression for the SELECT clause.
 
@@ -544,7 +529,7 @@ class SelectClauseMixin:
         Returns:
             CaseBuilder: A CaseBuilder instance for building the CASE expression.
         """
-        builder = cast("QueryBuilder[Any]", self)  # pyright: ignore
+        builder = cast("QueryBuilder", self)  # pyright: ignore
         return CaseBuilder(builder, alias)
 
 
@@ -552,11 +537,11 @@ class SelectClauseMixin:
 class CaseBuilder:
     """Builder for CASE expressions."""
 
-    _parent: "QueryBuilder[Any]"  # pyright: ignore
+    _parent: "QueryBuilder"  # pyright: ignore
     _alias: Optional[str]
     _case_expr: exp.Case
 
-    def __init__(self, parent: "QueryBuilder[Any]", alias: "Optional[str]" = None) -> None:
+    def __init__(self, parent: "QueryBuilder", alias: "Optional[str]" = None) -> None:
         """Initialize CaseBuilder.
 
         Args:
@@ -602,11 +587,11 @@ class CaseBuilder:
         self._case_expr.set("default", value_expr)
         return self
 
-    def end(self) -> "QueryBuilder[RowT]":
+    def end(self) -> "QueryBuilder":
         """Finalize the CASE expression and add it to the SELECT clause.
 
         Returns:
             The parent builder instance.
         """
         select_expr = exp.alias_(self._case_expr, self._alias) if self._alias else self._case_expr
-        return cast("QueryBuilder[Any]", self._parent.select(select_expr))  # type: ignore[attr-defined]
+        return cast("QueryBuilder", self._parent.select(select_expr))  # type: ignore[attr-defined]

sqlspec/{statement/builder → builder}/mixins/_update_operations.py

@@ -68,20 +68,15 @@ class UpdateSetClauseMixin:
             msg = "Cannot add SET clause to non-UPDATE expression."
             raise SQLBuilderError(msg)
         assignments = []
-        # (column, value) signature
         if len(args) == MIN_SET_ARGS and not kwargs:
             col, val = args
             col_expr = col if isinstance(col, exp.Column) else exp.column(col)
-            # If value is an expression, use it directly
             if isinstance(val, exp.Expression):
                 value_expr = val
             elif has_query_builder_parameters(val):
-                # It's a builder (like SelectBuilder), convert to subquery
                 subquery = val.build()
-                # Parse the SQL and use as expression
                 sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
                 value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
-                # Merge parameters from subquery
                 if has_query_builder_parameters(val):
                     for p_name, p_value in val.parameters.items():
                         self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
@@ -89,20 +84,15 @@ class UpdateSetClauseMixin:
                 param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
                 value_expr = exp.Placeholder(this=param_name)
             assignments.append(exp.EQ(this=col_expr, expression=value_expr))
-        # mapping and/or kwargs
         elif (len(args) == 1 and isinstance(args[0], Mapping)) or kwargs:
             all_values = dict(args[0] if args else {}, **kwargs)
             for col, val in all_values.items():
-                # If value is an expression, use it directly
                 if isinstance(val, exp.Expression):
                     value_expr = val
                 elif has_query_builder_parameters(val):
-                    # It's a builder (like SelectBuilder), convert to subquery
                     subquery = val.build()
-                    # Parse the SQL and use as expression
                     sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
                     value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
-                    # Merge parameters from subquery
                     if has_query_builder_parameters(val):
                         for p_name, p_value in val.parameters.items():
                             self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
@@ -113,7 +103,6 @@ class UpdateSetClauseMixin:
         else:
             msg = "Invalid arguments for set(): use (column, value), mapping, or kwargs."
             raise SQLBuilderError(msg)
-        # Append to existing expressions instead of replacing
         existing = self._expression.args.get("expressions", [])
         self._expression.set("expressions", existing + assignments)
         return self
@@ -142,9 +131,9 @@ class UpdateFromClauseMixin:
         if isinstance(table, str):
             table_expr = exp.to_table(table, alias=alias)
         elif has_query_builder_parameters(table):
-            subquery_builder_params = getattr(table, "_parameters", None)
-            if subquery_builder_params:
-                for p_name, p_value in subquery_builder_params.items():
+            subquery_builder_parameters = getattr(table, "_parameters", None)
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
                     self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             subquery_exp = exp.paren(getattr(table, "_expression", exp.select()))
             table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp

sqlspec/{statement/builder → builder}/mixins/_where_clause.py

@@ -1,18 +1,18 @@
 # ruff: noqa: PLR2004
 """Consolidated WHERE and HAVING clause mixins."""
 
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import parse_column_expression, parse_condition_expression
 from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder._parsing_utils import parse_column_expression, parse_condition_expression
 from sqlspec.utils.type_guards import has_query_builder_parameters, has_sqlglot_expression, is_iterable_parameters
 
 if TYPE_CHECKING:
+    from sqlspec.builder._column import ColumnExpression
     from sqlspec.protocols import SQLBuilderProtocol
-    from sqlspec.statement.builder._column import ColumnExpression
 
 __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
@@ -20,33 +20,6 @@ __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
-    def _create_operator_handler(self, operator_class: type[exp.Expression]) -> Callable:
-        """Create a handler that properly parameterizes values."""
-
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return operator_class(this=column_exp, expression=exp.Placeholder(this=param_name))
-
-        return handler
-
-    def _create_like_handler(self) -> Callable:
-        """Create LIKE handler."""
-
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
-
-        return handler
-
-    def _create_not_like_handler(self) -> Callable:
-        """Create NOT LIKE handler."""
-
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
-
-        return handler
-
     def _handle_in_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
         """Handle IN operator."""
         builder = cast("SQLBuilderProtocol", self)
@@ -126,7 +99,6 @@ class WhereClauseMixin:
             operator = str(condition[1]).upper()
             value = condition[2]
 
-            # Handle simple operators
             if operator == "=":
                 _, param_name = builder.add_parameter(value)
                 return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
@@ -152,7 +124,6 @@ class WhereClauseMixin:
                 _, param_name = builder.add_parameter(value)
                 return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
-            # Handle complex operators
             if operator == "IN":
                 return self._handle_in_operator(column_exp, value)
             if operator == "NOT IN":
@@ -175,15 +146,20 @@ class WhereClauseMixin:
     def where(
         self,
         condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression"],
+        value: Optional[Any] = None,
+        operator: Optional[str] = None,
     ) -> Self:
         """Add a WHERE clause to the statement.
 
         Args:
             condition: The condition for the WHERE clause. Can be:
-                - A string condition
+                - A string condition (when value is None)
+                - A string column name (when value is provided)
                 - A sqlglot Expression or Condition
                 - A 2-tuple (column, value) for equality comparison
                 - A 3-tuple (column, operator, value) for custom comparison
+            value: Value for comparison (when condition is a column name)
+            operator: Operator for comparison (when both condition and value provided)
 
         Raises:
             SQLBuilderError: If the current expression is not a supported statement type.
@@ -191,10 +167,7 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        # Special case: if this is an Update and _expression is not exp.Update, raise the expected error for test coverage
-        if self.__class__.__name__ == "Update" and not (
-            hasattr(self, "_expression") and isinstance(getattr(self, "_expression", None), exp.Update)
-        ):
+        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
 
@@ -203,35 +176,38 @@ class WhereClauseMixin:
             msg = "Cannot add WHERE clause: expression is not initialized."
             raise SQLBuilderError(msg)
 
-        # Check if DELETE has a table set
         if isinstance(builder._expression, exp.Delete) and not builder._expression.args.get("this"):
             msg = "WHERE clause requires a table to be set. Use from() to set the table first."
             raise SQLBuilderError(msg)
 
-        # Process different condition types
-        if isinstance(condition, str):
+        if value is not None:
+            if not isinstance(condition, str):
+                msg = "When value is provided, condition must be a column name (string)"
+                raise SQLBuilderError(msg)
+
+            if operator is not None:
+                where_expr = self._process_tuple_condition((condition, operator, value))
+            else:
+                where_expr = self._process_tuple_condition((condition, value))
+        elif isinstance(condition, str):
             where_expr = parse_condition_expression(condition)
         elif isinstance(condition, (exp.Expression, exp.Condition)):
             where_expr = condition
         elif isinstance(condition, tuple):
             where_expr = self._process_tuple_condition(condition)
         elif has_query_builder_parameters(condition):
-            # Handle ColumnExpression objects
             column_expr_obj = cast("ColumnExpression", condition)
             where_expr = column_expr_obj._expression  # pyright: ignore
         elif has_sqlglot_expression(condition):
-            # This is a ColumnExpression from our new Column syntax
-            raw_expr = getattr(condition, "sqlglot_expression", None)
+            raw_expr = condition.sqlglot_expression  # pyright: ignore[attr-defined]
             if raw_expr is not None:
                 where_expr = builder._parameterize_expression(raw_expr)
             else:
-                # Fallback if attribute exists but is None
                 where_expr = parse_condition_expression(str(condition))
         else:
             msg = f"Unsupported condition type: {type(condition).__name__}"
             raise SQLBuilderError(msg)
 
-        # Apply WHERE clause based on statement type
         if isinstance(builder._expression, (exp.Select, exp.Update, exp.Delete)):
             builder._expression = builder._expression.where(where_expr, copy=False)
         else:
@@ -302,7 +278,7 @@ class WhereClauseMixin:
         _, param_name = builder.add_parameter(pattern)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         if escape is not None:
-            cond = exp.Like(this=col_expr, expression=exp.var(param_name), escape=exp.Literal.string(str(escape)))
+            cond = exp.Like(this=col_expr, expression=exp.var(param_name), escape=exp.convert(str(escape)))
         else:
             cond = col_expr.like(exp.var(param_name))
         condition: exp.Expression = cond
@@ -344,8 +320,8 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                sql_str = subquery.sql
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = col_expr.isin(subquery_exp)
@@ -353,11 +329,11 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
-        params = []
+        parameters = []
         for v in values:
             _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        condition = col_expr.isin(*params)
+            parameters.append(exp.var(param_name))
+        condition = col_expr.isin(*parameters)
         return self.where(condition)
 
     def where_not_in(self, column: Union[str, exp.Column], values: Any) -> Self:
@@ -368,8 +344,8 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.Not(this=col_expr.isin(subquery_exp))
@@ -377,11 +353,11 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Values for where_not_in must be a non-string iterable or subquery."
             raise SQLBuilderError(msg)
-        params = []
+        parameters = []
         for v in values:
             _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        condition = exp.Not(this=col_expr.isin(*params))
+            parameters.append(exp.var(param_name))
+        condition = exp.Not(this=col_expr.isin(*parameters))
         return self.where(condition)
 
     def where_null(self, column: Union[str, exp.Column]) -> Self:
@@ -397,15 +373,15 @@ class WhereClauseMixin:
         builder = cast("SQLBuilderProtocol", self)
         sub_expr: exp.Expression
         if has_query_builder_parameters(subquery):
-            subquery_builder_params: dict[str, Any] = subquery.parameters
-            if subquery_builder_params:
-                for p_name, p_value in subquery_builder_params.items():
+            subquery_builder_parameters: dict[str, Any] = subquery.parameters
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
                     builder.add_parameter(p_value, name=p_name)
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sql_str = getattr(sub_sql_obj, "sql", str(sub_sql_obj))
-            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None))
+
+            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=builder.dialect_name)  # pyright: ignore
         else:
-            sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(str(subquery), dialect=builder.dialect_name)
 
         if sub_expr is None:
             msg = "Could not parse subquery for EXISTS"
@@ -419,15 +395,14 @@ class WhereClauseMixin:
         builder = cast("SQLBuilderProtocol", self)
         sub_expr: exp.Expression
         if has_query_builder_parameters(subquery):
-            subquery_builder_params: dict[str, Any] = subquery.parameters
-            if subquery_builder_params:
-                for p_name, p_value in subquery_builder_params.items():
+            subquery_builder_parameters: dict[str, Any] = subquery.parameters
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
                     builder.add_parameter(p_value, name=p_name)
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sql_str = getattr(sub_sql_obj, "sql", str(sub_sql_obj))
-            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=builder.dialect_name)  # pyright: ignore
         else:
-            sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(str(subquery), dialect=builder.dialect_name)
 
         if sub_expr is None:
             msg = "Could not parse subquery for NOT EXISTS"
@@ -444,8 +419,7 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
@@ -464,24 +438,23 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
-        params = []
+        parameters = []
         for v in values:
             _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
+            parameters.append(exp.var(param_name))
+        tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.EQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)
 
     def where_not_any(self, column: Union[str, exp.Column], values: Any) -> Self:
-        """Add WHERE column != ANY(values) clause."""
+        """Add WHERE column <> ANY(values) clause."""
         builder = cast("SQLBuilderProtocol", self)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
@@ -500,11 +473,11 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
-        params = []
+        parameters = []
         for v in values:
             _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
+            parameters.append(exp.var(param_name))
+        tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.NEQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)
 

sqlspec/cli.py

@@ -32,7 +32,7 @@ def get_sqlspec_group() -> "Group":
     @click.group(name="sqlspec")
     @click.option(
         "--config",
-        help="Dotted path to SQLAlchemy config(s) (e.g. 'myapp.config.sqlspec_configs')",
+        help="Dotted path to SQLSpec config(s) (e.g. 'myapp.config.sqlspec_configs')",
         required=True,
         type=str,
     )
@@ -87,7 +87,7 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         database_group = get_sqlspec_group()
 
     bind_key_option = click.option(
-        "--bind-key", help="Specify which SQLAlchemy config to use by bind key", type=str, default=None
+        "--bind-key", help="Specify which SQLSpec config to use by bind key", type=str, default=None
     )
     verbose_option = click.option("--verbose", help="Enable verbose output.", type=bool, default=False, is_flag=True)
     no_prompt_option = click.option(
@@ -103,21 +103,20 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
     def get_config_by_bind_key(
         ctx: "click.Context", bind_key: Optional[str]
     ) -> "Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]":
-        """Get the SQLAlchemy config for the specified bind key.
+        """Get the SQLSpec config for the specified bind key.
 
         Args:
             ctx: The click context.
             bind_key: The bind key to get the config for.
 
         Returns:
-            The SQLAlchemy config for the specified bind key.
+            The SQLSpec config for the specified bind key.
         """
         configs = ctx.obj["configs"]
         if bind_key is None:
             return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", configs[0])
 
         for config in configs:
-            # Check if config has a name or identifier attribute
             config_name = getattr(config, "name", None) or getattr(config, "bind_key", None)
             if config_name == bind_key:
                 return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", config)