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

sqlspec/builder/mixins/_where_clause.py

@@ -3,6 +3,10 @@
 
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
+if TYPE_CHECKING:
+    from sqlspec.core.statement import SQL
+
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -10,6 +14,30 @@ from sqlspec.builder._parsing_utils import parse_column_expression, parse_condit
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters, has_sqlglot_expression, is_iterable_parameters
 
+
+def _extract_column_name(column: Union[str, exp.Column]) -> str:
+    """Extract column name from column expression for parameter naming.
+
+    Args:
+        column: Column expression (string or SQLGlot Column)
+
+    Returns:
+        Column name as string for use as parameter name
+    """
+    if isinstance(column, str):
+        # Handle simple column names and table.column references
+        if "." in column:
+            return column.split(".")[-1]  # Return just the column part
+        return column
+    if isinstance(column, exp.Column):
+        # Extract the column name from SQLGlot Column expression
+        try:
+            return str(column.this.this)
+        except AttributeError:
+            return str(column.this) if column.this else "column"
+    return "column"
+
+
 if TYPE_CHECKING:
     from sqlspec.builder._column import ColumnExpression
     from sqlspec.protocols import SQLBuilderProtocol
@@ -17,31 +45,51 @@ if TYPE_CHECKING:
 __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
 
+@trait
 class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
-    def _handle_in_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    def _handle_in_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle IN operator."""
         builder = cast("SQLBuilderProtocol", self)
         if is_iterable_parameters(value):
             placeholders = []
-            for v in value:
-                _, param_name = builder.add_parameter(v)
+            for i, v in enumerate(value):
+                if len(value) == 1:
+                    param_name = builder._generate_unique_parameter_name(column_name)
+                else:
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
+                _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.In(this=column_exp, expressions=placeholders)
-        _, param_name = builder.add_parameter(value)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         return exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)])
 
-    def _handle_not_in_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_not_in_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle NOT IN operator."""
         builder = cast("SQLBuilderProtocol", self)
         if is_iterable_parameters(value):
             placeholders = []
-            for v in value:
-                _, param_name = builder.add_parameter(v)
+            for i, v in enumerate(value):
+                if len(value) == 1:
+                    param_name = builder._generate_unique_parameter_name(column_name)
+                else:
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
+                _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.Not(this=exp.In(this=column_exp, expressions=placeholders))
-        _, param_name = builder.add_parameter(value)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         return exp.Not(this=exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)]))
 
     def _handle_is_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
@@ -54,26 +102,34 @@ class WhereClauseMixin:
         value_expr = exp.Null() if value is None else exp.convert(value)
         return exp.Not(this=exp.Is(this=column_exp, expression=value_expr))
 
-    def _handle_between_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_between_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle BETWEEN operator."""
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            _, low_param = builder.add_parameter(low)
-            _, high_param = builder.add_parameter(high)
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
+            _, low_param = builder.add_parameter(low, name=low_param)
+            _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Between(
                 this=column_exp, low=exp.Placeholder(this=low_param), high=exp.Placeholder(this=high_param)
             )
         msg = f"BETWEEN operator requires a tuple of two values, got {type(value).__name__}"
         raise SQLBuilderError(msg)
 
-    def _handle_not_between_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_not_between_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle NOT BETWEEN operator."""
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            _, low_param = builder.add_parameter(low)
-            _, high_param = builder.add_parameter(high)
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
+            _, low_param = builder.add_parameter(low, name=low_param)
+            _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Not(
                 this=exp.Between(
                     this=column_exp, low=exp.Placeholder(this=low_param), high=exp.Placeholder(this=high_param)
@@ -85,13 +141,15 @@ class WhereClauseMixin:
     def _process_tuple_condition(self, condition: tuple) -> exp.Expression:
         """Process tuple-based WHERE conditions."""
         builder = cast("SQLBuilderProtocol", self)
-        column_name = str(condition[0])
-        column_exp = parse_column_expression(column_name)
+        column_name_raw = str(condition[0])
+        column_exp = parse_column_expression(column_name_raw)
+        column_name = _extract_column_name(column_name_raw)
 
         if len(condition) == 2:
             # (column, value) tuple for equality
             value = condition[1]
-            _, param_name = builder.add_parameter(value)
+            param_name = builder._generate_unique_parameter_name(column_name)
+            _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
 
         if len(condition) == 3:
@@ -100,42 +158,50 @@ class WhereClauseMixin:
             value = condition[2]
 
             if operator == "=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator in {"!=", "<>"}:
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.NEQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "LIKE":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "NOT LIKE":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
             if operator == "IN":
-                return self._handle_in_operator(column_exp, value)
+                return self._handle_in_operator(column_exp, value, column_name)
             if operator == "NOT IN":
-                return self._handle_not_in_operator(column_exp, value)
+                return self._handle_not_in_operator(column_exp, value, column_name)
             if operator == "IS":
                 return self._handle_is_operator(column_exp, value)
             if operator == "IS NOT":
                 return self._handle_is_not_operator(column_exp, value)
             if operator == "BETWEEN":
-                return self._handle_between_operator(column_exp, value)
+                return self._handle_between_operator(column_exp, value, column_name)
             if operator == "NOT BETWEEN":
-                return self._handle_not_between_operator(column_exp, value)
+                return self._handle_not_between_operator(column_exp, value, column_name)
 
             msg = f"Unsupported operator: {operator}"
             raise SQLBuilderError(msg)
@@ -145,7 +211,9 @@ class WhereClauseMixin:
 
     def where(
         self,
-        condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression"],
+        condition: Union[
+            str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression", "SQL"
+        ],
         value: Optional[Any] = None,
         operator: Optional[str] = None,
     ) -> Self:
@@ -167,7 +235,7 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
+        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
 
@@ -204,6 +272,25 @@ class WhereClauseMixin:
                 where_expr = builder._parameterize_expression(raw_expr)
             else:
                 where_expr = parse_condition_expression(str(condition))
+        elif hasattr(condition, "expression") and hasattr(condition, "sql"):
+            # Handle SQL objects (from sql.raw with parameters)
+            expression = getattr(condition, "expression", None)
+            if expression is not None and isinstance(expression, exp.Expression):
+                # Merge parameters from SQL object into builder
+                if hasattr(condition, "parameters") and hasattr(builder, "add_parameter"):
+                    sql_parameters = getattr(condition, "parameters", {})
+                    for param_name, param_value in sql_parameters.items():
+                        builder.add_parameter(param_value, name=param_name)
+                where_expr = expression
+            else:
+                # If expression is None, fall back to parsing the raw SQL
+                sql_text = getattr(condition, "sql", "")
+                # Merge parameters even when parsing raw SQL
+                if hasattr(condition, "parameters") and hasattr(builder, "add_parameter"):
+                    sql_parameters = getattr(condition, "parameters", {})
+                    for param_name, param_value in sql_parameters.items():
+                        builder.add_parameter(param_value, name=param_name)
+                where_expr = parse_condition_expression(sql_text)
         else:
             msg = f"Unsupported condition type: {type(condition).__name__}"
             raise SQLBuilderError(msg)
@@ -218,86 +305,107 @@ class WhereClauseMixin:
     def where_eq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column = value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.eq(exp.var(param_name))
+        condition: exp.Expression = col_expr.eq(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_neq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column != value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.neq(exp.var(param_name))
+        condition: exp.Expression = col_expr.neq(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_lt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column < value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.LT(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.LT(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_lte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column <= value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_gt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column > value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.GT(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.GT(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_gte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column >= value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_between(self, column: Union[str, exp.Column], low: Any, high: Any) -> Self:
         """Add WHERE column BETWEEN low AND high clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, low_param = builder.add_parameter(low)
-        _, high_param = builder.add_parameter(high)
+        column_name = _extract_column_name(column)
+        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
+        _, low_param = builder.add_parameter(low, name=low_param)
+        _, high_param = builder.add_parameter(high, name=high_param)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.between(exp.var(low_param), exp.var(high_param))
+        condition: exp.Expression = col_expr.between(exp.Placeholder(this=low_param), exp.Placeholder(this=high_param))
         return self.where(condition)
 
     def where_like(self, column: Union[str, exp.Column], pattern: str, escape: Optional[str] = None) -> Self:
         """Add WHERE column LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         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.convert(str(escape)))
+            cond = exp.Like(this=col_expr, expression=exp.Placeholder(this=param_name), escape=exp.convert(str(escape)))
         else:
-            cond = col_expr.like(exp.var(param_name))
+            cond = col_expr.like(exp.Placeholder(this=param_name))
         condition: exp.Expression = cond
         return self.where(condition)
 
     def where_not_like(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column NOT LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.like(exp.var(param_name)).not_()
+        condition: exp.Expression = col_expr.like(exp.Placeholder(this=param_name)).not_()
         return self.where(condition)
 
     def where_ilike(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column ILIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.ilike(exp.var(param_name))
+        condition: exp.Expression = col_expr.ilike(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_is_null(self, column: Union[str, exp.Column]) -> Self:
@@ -322,6 +430,10 @@ class WhereClauseMixin:
                 subquery = values.build()  # pyright: ignore
                 sql_str = subquery.sql
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=builder.dialect_name))  # pyright: ignore
+                # Merge subquery parameters into parent builder
+                if hasattr(subquery, "parameters") and isinstance(subquery.parameters, dict):  # pyright: ignore[reportAttributeAccessIssue]
+                    for param_name, param_value in subquery.parameters.items():  # pyright: ignore[reportAttributeAccessIssue]
+                        builder.add_parameter(param_value, name=param_name)
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = col_expr.isin(subquery_exp)
@@ -329,10 +441,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         condition = col_expr.isin(*parameters)
         return self.where(condition)
 
@@ -353,10 +470,15 @@ 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)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         condition = exp.Not(this=col_expr.isin(*parameters))
         return self.where(condition)
 
@@ -438,10 +560,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.EQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)
@@ -473,19 +600,27 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.NEQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)
 
 
+@trait
 class HavingClauseMixin:
     """Mixin providing HAVING clause for SELECT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    _expression: Optional[exp.Expression]
 
     def having(self, condition: Union[str, exp.Expression]) -> Self:
         """Add HAVING clause.

sqlspec/core/cache.py

@@ -245,19 +245,21 @@ class UnifiedCache(Generic[CacheValueT]):
             Cached value or None if not found or expired
         """
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 self._stats.record_miss()
                 return None
 
-            current_time: float = time.time()
-            ttl: Optional[int] = self._ttl
-            if ttl is not None and (current_time - node.timestamp) > ttl:
-                self._remove_node(node)
-                del self._cache[key]
-                self._stats.record_miss()
-                self._stats.record_eviction()
-                return None
+            # Optimize TTL check with early variable assignment
+            ttl = self._ttl
+            if ttl is not None:
+                current_time = time.time()
+                if (current_time - node.timestamp) > ttl:
+                    self._remove_node(node)
+                    del self._cache[key]
+                    self._stats.record_miss()
+                    self._stats.record_eviction()
+                    return None
 
             self._move_to_head(node)
             node.access_count += 1
@@ -272,7 +274,7 @@ class UnifiedCache(Generic[CacheValueT]):
             value: Value to cache
         """
         with self._lock:
-            existing_node: Optional[CacheNode] = self._cache.get(key)
+            existing_node = self._cache.get(key)
             if existing_node is not None:
                 existing_node.value = value
                 existing_node.timestamp = time.time()
@@ -280,14 +282,13 @@ class UnifiedCache(Generic[CacheValueT]):
                 self._move_to_head(existing_node)
                 return
 
-            new_node: CacheNode = CacheNode(key, value)
+            new_node = CacheNode(key, value)
             self._cache[key] = new_node
             self._add_to_head(new_node)
 
-            cache_size: int = len(self._cache)
-            max_size: int = self._max_size
-            if cache_size > max_size:
-                tail_node: Optional[CacheNode] = self._tail.prev
+            # Optimize size check with cached length
+            if len(self._cache) > self._max_size:
+                tail_node = self._tail.prev
                 if tail_node is not None and tail_node is not self._head:
                     self._remove_node(tail_node)
                     del self._cache[tail_node.key]
@@ -361,17 +362,13 @@ class UnifiedCache(Generic[CacheValueT]):
     def __contains__(self, key: CacheKey) -> bool:
         """Check if key exists in cache."""
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 return False
 
-            ttl: Optional[int] = self._ttl
-            if ttl is not None:
-                current_time: float = time.time()
-                if (current_time - node.timestamp) > ttl:
-                    return False
-
-            return True
+            # Optimize TTL check
+            ttl = self._ttl
+            return not (ttl is not None and time.time() - node.timestamp > ttl)
 
 
 @mypyc_attr(allow_interpreted_subclasses=False)
@@ -553,6 +550,8 @@ class ParameterCache:
         """
         # Create stable key from parameters and configuration
         try:
+            # Optimize type checking order
+            param_key: tuple[Any, ...]
             if isinstance(params, dict):
                 param_key = tuple(sorted(params.items()))
             elif isinstance(params, (list, tuple)):
@@ -560,12 +559,11 @@ class ParameterCache:
             else:
                 param_key = (params,)
 
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            return CacheKey(("parameters", param_key, config_hash))
         except (TypeError, ValueError):
-            param_key = (str(params), type(params).__name__)  # type: ignore[assignment]
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            # Fallback for unhashable types
+            param_key_fallback = (str(params), type(params).__name__)
+            return CacheKey(("parameters", param_key_fallback, config_hash))
 
     def clear(self) -> None:
         """Clear parameter cache."""