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

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

@@ -3,8 +3,8 @@ 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_table_expression
 from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder._parsing_utils import parse_table_expression
 from sqlspec.utils.type_guards import has_query_builder_parameters
 
 if TYPE_CHECKING:
@@ -33,7 +33,6 @@ class JoinClauseMixin:
         if isinstance(table, str):
             table_expr = parse_table_expression(table, alias)
         elif has_query_builder_parameters(table):
-            # Work directly with AST when possible to avoid string parsing
             if hasattr(table, "_expression") and getattr(table, "_expression", None) is not None:
                 table_expr_value = getattr(table, "_expression", None)
                 if table_expr_value is not None:
@@ -46,7 +45,6 @@ class JoinClauseMixin:
                 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)))
                 table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
-            # Parameter merging logic can be added here if needed
         else:
             table_expr = table
         on_expr: Optional[exp.Expression] = None

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

@@ -70,10 +70,9 @@ class MergeUsingClauseMixin:
         if isinstance(source, str):
             source_expr = exp.to_table(source, alias=alias)
         elif has_query_builder_parameters(source) and hasattr(source, "_expression"):
-            # Merge parameters from the SELECT builder or other builder
-            subquery_builder_params = source.parameters
-            if subquery_builder_params:
-                for p_name, p_value in subquery_builder_params.items():
+            subquery_builder_parameters = source.parameters
+            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(source, "_expression", exp.select()))
@@ -173,7 +172,11 @@ class MergeMatchedClauseMixin:
         """
         update_expressions: list[exp.EQ] = []
         for col, val in set_values.items():
-            param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {"matched": True, "then": exp.Update(expressions=update_expressions)}
@@ -271,8 +274,12 @@ class MergeNotMatchedClauseMixin:
                 raise SQLBuilderError(msg)
 
             parameterized_values: list[exp.Expression] = []
-            for val in values:
-                param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            for i, val in enumerate(values):
+                column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
                 parameterized_values.append(exp.var(param_name))
 
             insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
@@ -281,7 +288,6 @@ class MergeNotMatchedClauseMixin:
             msg = "Specifying columns without values for INSERT action is complex and not fully supported yet. Consider providing full expressions."
             raise SQLBuilderError(msg)
         elif not columns and not values:
-            # INSERT DEFAULT VALUES case
             pass
         else:
             msg = "Cannot specify values without columns for INSERT action."
@@ -338,7 +344,11 @@ class MergeNotMatchedBySourceClauseMixin:
         """
         update_expressions: list[exp.EQ] = []
         for col, val in set_values.items():
-            param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {

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

@@ -5,8 +5,8 @@ from typing import TYPE_CHECKING, Optional, Union, cast
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import parse_order_expression
 from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder._parsing_utils import parse_order_expression
 
 if TYPE_CHECKING:
     from sqlspec.protocols import SQLBuilderProtocol
@@ -71,7 +71,7 @@ class LimitOffsetClauseMixin:
         if not isinstance(builder._expression, exp.Select):
             msg = "LIMIT is only supported for SELECT statements."
             raise SQLBuilderError(msg)
-        builder._expression = builder._expression.limit(exp.Literal.number(value), copy=False)
+        builder._expression = builder._expression.limit(exp.convert(value), copy=False)
         return cast("Self", builder)
 
     def offset(self, value: int) -> Self:
@@ -90,7 +90,7 @@ class LimitOffsetClauseMixin:
         if not isinstance(builder._expression, exp.Select):
             msg = "OFFSET is only supported for SELECT statements."
             raise SQLBuilderError(msg)
-        builder._expression = builder._expression.offset(exp.Literal.number(value), copy=False)
+        builder._expression = builder._expression.offset(exp.convert(value), copy=False)
         return cast("Self", builder)
 
 

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:
@@ -578,7 +563,8 @@ class CaseBuilder:
             CaseBuilder: The current builder instance for method chaining.
         """
         cond_expr = exp.condition(condition) if isinstance(condition, str) else condition
-        param_name = self._parent.add_parameter(value)[1]
+        param_name = self._parent._generate_unique_parameter_name("case_when_value")
+        param_name = self._parent.add_parameter(value, name=param_name)[1]
         value_expr = exp.Placeholder(this=param_name)
 
         when_clause = exp.When(this=cond_expr, then=value_expr)
@@ -597,16 +583,17 @@ class CaseBuilder:
         Returns:
             CaseBuilder: The current builder instance for method chaining.
         """
-        param_name = self._parent.add_parameter(value)[1]
+        param_name = self._parent._generate_unique_parameter_name("case_else_value")
+        param_name = self._parent.add_parameter(value, name=param_name)[1]
         value_expr = exp.Placeholder(this=param_name)
         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,52 +68,51 @@ 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]
             else:
-                param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+                column_name = col if isinstance(col, str) else str(col)
+                # Extract just the column part if table.column format
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = self.add_parameter(val, name=param_name)[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]
                 else:
-                    param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+                    # Extract column name for parameter naming
+                    column_name = col if isinstance(col, str) else str(col)
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
                     value_expr = exp.Placeholder(this=param_name)
                 assignments.append(exp.EQ(this=exp.column(col), expression=value_expr))
         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 +141,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