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

sqlspec/builder/_base.py

@@ -5,7 +5,6 @@ with automatic parameter binding and validation.
 """
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, NoReturn, Optional, Union, cast
 
 import sqlglot
@@ -31,16 +30,19 @@ __all__ = ("QueryBuilder", "SafeQuery")
 logger = get_logger(__name__)
 
 
-@dataclass(frozen=True)
 class SafeQuery:
     """A safely constructed SQL query with bound parameters."""
 
-    sql: str
-    parameters: dict[str, Any] = field(default_factory=dict)
-    dialect: DialectType = field(default=None)
+    __slots__ = ("dialect", "parameters", "sql")
+
+    def __init__(
+        self, sql: str, parameters: Optional[dict[str, Any]] = None, dialect: Optional[DialectType] = None
+    ) -> None:
+        self.sql = sql
+        self.parameters = parameters if parameters is not None else {}
+        self.dialect = dialect
 
 
-@dataclass
 class QueryBuilder(ABC):
     """Abstract base class for SQL query builders with SQLGlot optimization.
 
@@ -48,18 +50,43 @@ class QueryBuilder(ABC):
     query construction, and query optimization using SQLGlot.
     """
 
-    dialect: DialectType = field(default=None)
-    schema: Optional[dict[str, dict[str, str]]] = field(default=None)
-    _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
-    _parameters: dict[str, Any] = field(default_factory=dict, init=False, repr=False, compare=False, hash=False)
-    _parameter_counter: int = field(default=0, init=False, repr=False, compare=False, hash=False)
-    _with_ctes: dict[str, exp.CTE] = field(default_factory=dict, init=False, repr=False, compare=False, hash=False)
-    enable_optimization: bool = field(default=True, init=True)
-    optimize_joins: bool = field(default=True, init=True)
-    optimize_predicates: bool = field(default=True, init=True)
-    simplify_expressions: bool = field(default=True, init=True)
-
-    def __post_init__(self) -> None:
+    __slots__ = (
+        "_expression",
+        "_parameter_counter",
+        "_parameters",
+        "_with_ctes",
+        "dialect",
+        "enable_optimization",
+        "optimize_joins",
+        "optimize_predicates",
+        "schema",
+        "simplify_expressions",
+    )
+
+    def __init__(
+        self,
+        dialect: Optional[DialectType] = None,
+        schema: Optional[dict[str, dict[str, str]]] = None,
+        enable_optimization: bool = True,
+        optimize_joins: bool = True,
+        optimize_predicates: bool = True,
+        simplify_expressions: bool = True,
+    ) -> None:
+        self.dialect = dialect
+        self.schema = schema
+        self.enable_optimization = enable_optimization
+        self.optimize_joins = optimize_joins
+        self.optimize_predicates = optimize_predicates
+        self.simplify_expressions = simplify_expressions
+
+        # Initialize mutable attributes
+        self._expression: Optional[exp.Expression] = None
+        self._parameters: dict[str, Any] = {}
+        self._parameter_counter: int = 0
+        self._with_ctes: dict[str, exp.CTE] = {}
+
+    def _initialize_expression(self) -> None:
+        """Initialize the base expression. Called after __init__."""
         self._expression = self._create_base_expression()
         if not self._expression:
             self._raise_sql_builder_error(
@@ -135,7 +162,7 @@ class QueryBuilder(ABC):
                 return exp.Placeholder(this=param_name)
             return node
 
-        return expression.transform(replacer, copy=True)
+        return expression.transform(replacer, copy=False)
 
     def add_parameter(self: Self, value: Any, name: Optional[str] = None) -> tuple[Self, str]:
         """Explicitly adds a parameter to the query.
@@ -154,13 +181,13 @@ class QueryBuilder(ABC):
         if name:
             if name in self._parameters:
                 self._raise_sql_builder_error(f"Parameter name '{name}' already exists.")
-            param_name_to_use = name
-        else:
-            self._parameter_counter += 1
-            param_name_to_use = f"param_{self._parameter_counter}"
+            self._parameters[name] = value
+            return self, name
 
-        self._parameters[param_name_to_use] = value
-        return self, param_name_to_use
+        self._parameter_counter += 1
+        param_name = f"param_{self._parameter_counter}"
+        self._parameters[param_name] = value
+        return self, param_name
 
     def _generate_unique_parameter_name(self, base_name: str) -> str:
         """Generate unique parameter name when collision occurs.
@@ -174,12 +201,15 @@ class QueryBuilder(ABC):
         if base_name not in self._parameters:
             return base_name
 
-        i = 1
-        while True:
+        for i in range(1, 1000):  # Reasonable upper bound to prevent infinite loops
             name = f"{base_name}_{i}"
             if name not in self._parameters:
                 return name
-            i += 1
+
+        # Fallback for edge case
+        import uuid
+
+        return f"{base_name}_{uuid.uuid4().hex[:8]}"
 
     def _generate_builder_cache_key(self, config: "Optional[StatementConfig]" = None) -> str:
         """Generate cache key based on builder state and configuration.
@@ -192,11 +222,14 @@ class QueryBuilder(ABC):
         """
         import hashlib
 
-        state_components = [
-            f"expression:{self._expression.sql() if self._expression else 'None'}",
+        dialect_name: str = self.dialect_name or "default"
+        expr_sql: str = self._expression.sql() if self._expression else "None"
+
+        state_parts = [
+            f"expression:{expr_sql}",
             f"parameters:{sorted(self._parameters.items())}",
             f"ctes:{sorted(self._with_ctes.keys())}",
-            f"dialect:{self.dialect_name or 'default'}",
+            f"dialect:{dialect_name}",
             f"schema:{self.schema}",
             f"optimization:{self.enable_optimization}",
             f"optimize_joins:{self.optimize_joins}",
@@ -205,7 +238,7 @@ class QueryBuilder(ABC):
         ]
 
         if config:
-            config_components = [
+            config_parts = [
                 f"config_dialect:{config.dialect or 'default'}",
                 f"enable_parsing:{config.enable_parsing}",
                 f"enable_validation:{config.enable_validation}",
@@ -214,12 +247,10 @@ class QueryBuilder(ABC):
                 f"enable_caching:{config.enable_caching}",
                 f"param_style:{config.parameter_config.default_parameter_style.value}",
             ]
-            state_components.extend(config_components)
+            state_parts.extend(config_parts)
 
-        state_string = "|".join(state_components)
-        cache_key = hashlib.sha256(state_string.encode()).hexdigest()[:16]
-
-        return f"builder:{cache_key}"
+        state_string = "|".join(state_parts)
+        return f"builder:{hashlib.sha256(state_string.encode()).hexdigest()[:16]}"
 
     def with_cte(self: Self, alias: str, query: "Union[QueryBuilder, exp.Select, str]") -> Self:
         """Adds a Common Table Expression (CTE) to the query.
@@ -243,7 +274,7 @@ class QueryBuilder(ABC):
             if not isinstance(query._expression, exp.Select):
                 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()
+            cte_select_expression = query._expression
             for p_name, p_value in query.parameters.items():
                 unique_name = self._generate_unique_parameter_name(p_name)
                 self.add_parameter(p_value, unique_name)
@@ -261,7 +292,7 @@ class QueryBuilder(ABC):
                 msg = f"An unexpected error occurred while parsing CTE query string: {e!s}"
                 self._raise_sql_builder_error(msg, e)
         elif isinstance(query, exp.Select):
-            cte_select_expression = query.copy()
+            cte_select_expression = query
         else:
             msg = f"Invalid query type for CTE: {type(query).__name__}"
             self._raise_sql_builder_error(msg)
@@ -280,14 +311,14 @@ class QueryBuilder(ABC):
             self._raise_sql_builder_error("QueryBuilder expression not initialized.")
 
         if self._with_ctes:
-            final_expression = self._expression.copy()
+            final_expression = self._expression
             if has_with_method(final_expression):
                 for alias, cte_node in self._with_ctes.items():
                     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)
         else:
-            final_expression = self._expression.copy() if self.enable_optimization else self._expression
+            final_expression = self._expression
 
         if self.enable_optimization and isinstance(final_expression, exp.Expression):
             final_expression = self._optimize_expression(final_expression)
@@ -335,10 +366,10 @@ class QueryBuilder(ABC):
 
         try:
             optimized = optimize(
-                expression.copy(), schema=self.schema, dialect=self.dialect_name, optimizer_settings=optimizer_settings
+                expression, schema=self.schema, dialect=self.dialect_name, optimizer_settings=optimizer_settings
             )
 
-            unified_cache.put(cache_key_obj, optimized.copy())
+            unified_cache.put(cache_key_obj, optimized)
 
         except Exception:
             return expression
@@ -430,8 +461,10 @@ class QueryBuilder(ABC):
                 return self.dialect.__name__.lower()
             if isinstance(self.dialect, Dialect):
                 return type(self.dialect).__name__.lower()
-            if hasattr(self.dialect, "__name__"):
+            try:
                 return self.dialect.__name__.lower()
+            except AttributeError:
+                pass
         return None
 
     @property

sqlspec/builder/_column.py

@@ -67,7 +67,6 @@ class Column:
         else:
             self._expression = exp.Column(this=exp.Identifier(this=name))
 
-    # Comparison operators
     def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
         """Equal to (==)."""
         if other is None:
@@ -100,7 +99,6 @@ class Column:
         """Apply NOT operator (~)."""
         return ColumnExpression(exp.Not(this=self._expression))
 
-    # SQL-specific methods
     def like(self, pattern: str, escape: Optional[str] = None) -> ColumnExpression:
         """SQL LIKE pattern matching."""
         if escape:
@@ -152,7 +150,6 @@ class Column:
         converted_values = [exp.convert(v) for v in values]
         return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
-    # SQL Functions
     def lower(self) -> "FunctionColumn":
         """SQL LOWER() function."""
         return FunctionColumn(exp.Lower(this=self._expression))
@@ -203,7 +200,6 @@ class Column:
         """SQL CAST() function."""
         return FunctionColumn(exp.Cast(this=self._expression, to=exp.DataType.build(data_type)))
 
-    # Aggregate functions
     def count(self) -> "FunctionColumn":
         """SQL COUNT() function."""
         return FunctionColumn(exp.Count(this=self._expression))

sqlspec/builder/_ddl.py

@@ -45,7 +45,8 @@ class DDLBuilder(QueryBuilder):
     _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
 
     def __post_init__(self) -> None:
-        pass
+        # Initialize parent class attributes since dataclass doesn't call super().__init__()
+        super().__init__(dialect=self.dialect)
 
     def _create_base_expression(self) -> exp.Expression:
         msg = "Subclasses must implement _create_base_expression."
@@ -64,7 +65,6 @@ class DDLBuilder(QueryBuilder):
         return super().to_statement(config=config)
 
 
-# --- Data Structures for CREATE TABLE ---
 @dataclass
 class ColumnDefinition:
     """Column definition for CREATE TABLE."""
@@ -78,7 +78,7 @@ class ColumnDefinition:
     auto_increment: bool = False
     comment: "Optional[str]" = None
     check: "Optional[str]" = None
-    generated: "Optional[str]" = None  # For computed columns
+    generated: "Optional[str]" = None
     collate: "Optional[str]" = None
 
 
@@ -86,7 +86,7 @@ class ColumnDefinition:
 class ConstraintDefinition:
     """Constraint definition for CREATE TABLE."""
 
-    constraint_type: str  # 'PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK'
+    constraint_type: str
     name: "Optional[str]" = None
     columns: "list[str]" = field(default_factory=list)
     references_table: "Optional[str]" = None
@@ -98,7 +98,6 @@ class ConstraintDefinition:
     initially_deferred: bool = False
 
 
-# --- CREATE TABLE ---
 @dataclass
 class CreateTable(DDLBuilder):
     """Builder for CREATE TABLE statements with columns and constraints.
@@ -199,7 +198,6 @@ class CreateTable(DDLBuilder):
 
         self._columns.append(column_def)
 
-        # If primary key is specified on column, also add a constraint
         if primary_key and not any(c.constraint_type == "PRIMARY KEY" for c in self._constraints):
             self.primary_key_constraint([name])
 
@@ -235,12 +233,10 @@ class CreateTable(DDLBuilder):
         initially_deferred: bool = False,
     ) -> "Self":
         """Add a foreign key constraint."""
-        # Normalize inputs
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         ref_col_list = [references_columns] if isinstance(references_columns, str) else list(references_columns)
 
-        # Validation
         if len(col_list) != len(ref_col_list):
             self._raise_sql_builder_error("Foreign key columns and referenced columns must have same length")
 
@@ -267,7 +263,6 @@ class CreateTable(DDLBuilder):
 
     def unique_constraint(self, columns: "Union[str, list[str]]", name: "Optional[str]" = None) -> "Self":
         """Add a unique constraint."""
-        # Normalize column list
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         if not col_list:
@@ -285,11 +280,9 @@ class CreateTable(DDLBuilder):
 
         condition_str: str
         if hasattr(condition, "sqlglot_expression"):
-            # This is a ColumnExpression - render as raw SQL for DDL (no parameters)
             sqlglot_expr = getattr(condition, "sqlglot_expression", None)
             condition_str = sqlglot_expr.sql(dialect=self.dialect) if sqlglot_expr else str(condition)
         else:
-            # String condition - use as-is
             condition_str = str(condition)
 
         constraint = ConstraintDefinition(constraint_type="CHECK", name=name, condition=condition_str)
@@ -338,7 +331,6 @@ class CreateTable(DDLBuilder):
             column_defs.append(col_expr)
 
         for constraint in self._constraints:
-            # Skip PRIMARY KEY constraints that are already defined on columns
             if constraint.constraint_type == "PRIMARY KEY" and len(constraint.columns) == 1:
                 col_name = constraint.columns[0]
                 if any(c.name == col_name and c.primary_key for c in self._columns):
@@ -361,7 +353,7 @@ class CreateTable(DDLBuilder):
             props.append(exp.Property(this=exp.to_identifier("PARTITION BY"), value=exp.convert(self._partition_by)))
 
         for key, value in self._table_options.items():
-            if key != "engine":  # Skip already handled options
+            if key != "engine":
                 props.append(exp.Property(this=exp.to_identifier(key.upper()), value=exp.convert(value)))
 
         properties_node = exp.Properties(expressions=props) if props else None
@@ -393,14 +385,13 @@ class CreateTable(DDLBuilder):
         return build_constraint_expression(constraint)
 
 
-# --- DROP TABLE ---
 @dataclass
 class DropTable(DDLBuilder):
     """Builder for DROP TABLE [IF EXISTS] ... [CASCADE|RESTRICT]."""
 
     _table_name: Optional[str] = None
     _if_exists: bool = False
-    _cascade: Optional[bool] = None  # True: CASCADE, False: RESTRICT, None: not set
+    _cascade: Optional[bool] = None
 
     def __init__(self, table_name: str, **kwargs: Any) -> None:
         """Initialize DROP TABLE with table name.
@@ -436,7 +427,6 @@ class DropTable(DDLBuilder):
         )
 
 
-# --- DROP INDEX ---
 @dataclass
 class DropIndex(DDLBuilder):
     """Builder for DROP INDEX [IF EXISTS] ... [ON table] [CASCADE|RESTRICT]."""
@@ -488,7 +478,6 @@ class DropIndex(DDLBuilder):
         )
 
 
-# --- DROP VIEW ---
 @dataclass
 class DropView(DDLBuilder):
     """Builder for DROP VIEW [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -521,7 +510,6 @@ class DropView(DDLBuilder):
         )
 
 
-# --- DROP SCHEMA ---
 @dataclass
 class DropSchema(DDLBuilder):
     """Builder for DROP SCHEMA [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -554,7 +542,6 @@ class DropSchema(DDLBuilder):
         )
 
 
-# --- CREATE INDEX ---
 @dataclass
 class CreateIndex(DDLBuilder):
     """Builder for CREATE [UNIQUE] INDEX [IF NOT EXISTS] ... ON ... (...).
@@ -579,7 +566,6 @@ class CreateIndex(DDLBuilder):
         """
         super().__init__(**kwargs)
         self._index_name = index_name
-        # Initialize dataclass fields that may not be set by super().__init__
         if not hasattr(self, "_columns"):
             self._columns = []
 
@@ -627,7 +613,6 @@ class CreateIndex(DDLBuilder):
         where_expr = None
         if self._where:
             where_expr = exp.condition(self._where) if isinstance(self._where, str) else self._where
-        # Use exp.Create for CREATE INDEX
         return exp.Create(
             kind="INDEX",
             this=exp.to_identifier(self._index_name),
@@ -640,14 +625,13 @@ class CreateIndex(DDLBuilder):
         )
 
 
-# --- TRUNCATE TABLE ---
 @dataclass
 class Truncate(DDLBuilder):
     """Builder for TRUNCATE TABLE ... [CASCADE|RESTRICT] [RESTART IDENTITY|CONTINUE IDENTITY]."""
 
     _table_name: Optional[str] = None
     _cascade: Optional[bool] = None
-    _identity: Optional[str] = None  # "RESTART" or "CONTINUE"
+    _identity: Optional[str] = None
 
     def table(self, name: str) -> Self:
         self._table_name = name
@@ -676,7 +660,6 @@ class Truncate(DDLBuilder):
         return exp.TruncateTable(this=exp.to_table(self._table_name), cascade=self._cascade, identity=identity_expr)
 
 
-# --- ALTER TABLE ---
 @dataclass
 class AlterOperation:
     """Represents a single ALTER TABLE operation."""
@@ -693,7 +676,6 @@ class AlterOperation:
     using_expression: "Optional[str]" = None
 
 
-# --- CREATE SCHEMA ---
 @dataclass
 class CreateSchema(DDLBuilder):
     """Builder for CREATE SCHEMA [IF NOT EXISTS] schema_name [AUTHORIZATION user_name]."""
@@ -757,7 +739,7 @@ class CreateTableAsSelect(DDLBuilder):
     _table_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
+    _select_query: Optional[object] = None
 
     def name(self, table_name: str) -> Self:
         self._table_name = table_name
@@ -797,11 +779,7 @@ class CreateTableAsSelect(DDLBuilder):
             if with_ctes and select_expr and isinstance(select_expr, exp.Select):
                 for alias, cte in with_ctes.items():
                     if hasattr(select_expr, "with_"):
-                        select_expr = select_expr.with_(
-                            cte.this,  # The CTE's SELECT expression
-                            as_=alias,
-                            copy=False,
-                        )
+                        select_expr = select_expr.with_(cte.this, as_=alias, copy=False)
         elif isinstance(self._select_query, str):
             select_expr = exp.maybe_parse(self._select_query)
             select_parameters = None
@@ -810,11 +788,8 @@ class CreateTableAsSelect(DDLBuilder):
         if select_expr is None:
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -840,8 +815,8 @@ class CreateMaterializedView(DDLBuilder):
     _view_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
-    _with_data: Optional[bool] = None  # True: WITH DATA, False: NO DATA, None: not set
+    _select_query: Optional[object] = None
+    _with_data: Optional[bool] = None
     _refresh_mode: Optional[str] = None
     _storage_parameters: dict[str, Any] = field(default_factory=dict)
     _tablespace: Optional[str] = None
@@ -917,11 +892,8 @@ class CreateMaterializedView(DDLBuilder):
         if select_expr is None or not isinstance(select_expr, exp.Select):
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -964,7 +936,7 @@ class CreateView(DDLBuilder):
     _view_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
+    _select_query: Optional[object] = None
     _hints: list[str] = field(default_factory=list)
 
     def name(self, view_name: str) -> Self:
@@ -1012,11 +984,8 @@ class CreateView(DDLBuilder):
         if select_expr is None or not isinstance(select_expr, exp.Select):
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -1164,17 +1133,14 @@ class AlterTable(DDLBuilder):
         if constraint_type.upper() not in valid_types:
             self._raise_sql_builder_error(f"Invalid constraint type: {constraint_type}")
 
-        # Normalize columns
         col_list = None
         if columns is not None:
             col_list = [columns] if isinstance(columns, str) else list(columns)
 
-        # Normalize reference columns
         ref_col_list = None
         if references_columns is not None:
             ref_col_list = [references_columns] if isinstance(references_columns, str) else list(references_columns)
 
-        # Handle ColumnExpression for CHECK constraints
         condition_str: Optional[str] = None
         if condition is not None:
             if hasattr(condition, "sqlglot_expression"):
@@ -1246,9 +1212,6 @@ class AlterTable(DDLBuilder):
         if op_type == "ADD COLUMN":
             if not op.column_definition:
                 self._raise_sql_builder_error("Column definition required for ADD COLUMN")
-            # SQLGlot expects a ColumnDef directly for ADD COLUMN actions
-            # Note: SQLGlot doesn't support AFTER/FIRST positioning in standard ALTER TABLE ADD COLUMN
-            # These would need to be handled at the dialect level
             return build_column_expression(op.column_definition)
 
         if op_type == "DROP COLUMN":
@@ -1311,7 +1274,7 @@ class AlterTable(DDLBuilder):
             return exp.AlterColumn(this=exp.to_identifier(op.column_name), kind="DROP DEFAULT")
 
         self._raise_sql_builder_error(f"Unknown operation type: {op.operation_type}")
-        raise AssertionError  # This line is unreachable but satisfies the linter
+        raise AssertionError
 
 
 @dataclass
@@ -1321,7 +1284,7 @@ class CommentOn(DDLBuilder):
     Supports COMMENT ON TABLE and COMMENT ON COLUMN.
     """
 
-    _target_type: Optional[str] = None  # 'TABLE' or 'COLUMN'
+    _target_type: Optional[str] = None
     _table: Optional[str] = None
     _column: Optional[str] = None
     _comment: Optional[str] = None
@@ -1352,7 +1315,7 @@ class CommentOn(DDLBuilder):
                 expression=exp.convert(self._comment),
             )
         self._raise_sql_builder_error("Must specify target and comment for COMMENT ON statement.")
-        raise AssertionError  # This line is unreachable but satisfies the linter
+        raise AssertionError
 
 
 @dataclass

sqlspec/builder/_ddl_utils.py

@@ -33,7 +33,6 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
             else:
                 default_expr = exp.convert(col.default)
         else:
-            # Use exp.convert for all other types (int, float, bool, None, etc.)
             default_expr = exp.convert(col.default)
 
         constraints.append(exp.ColumnConstraint(kind=default_expr))

sqlspec/builder/_delete.py

@@ -4,7 +4,6 @@ This module provides a fluent interface for building SQL queries safely,
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from sqlglot import exp
@@ -12,11 +11,11 @@ from sqlglot import exp
 from sqlspec.builder._base import QueryBuilder, SafeQuery
 from sqlspec.builder.mixins import DeleteFromClauseMixin, ReturningClauseMixin, WhereClauseMixin
 from sqlspec.core.result import SQLResult
+from sqlspec.exceptions import SQLBuilderError
 
 __all__ = ("Delete",)
 
 
-@dataclass(unsafe_hash=True)
 class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromClauseMixin):
     """Builder for DELETE statements.
 
@@ -25,7 +24,8 @@ class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromCla
     operations to maintain cross-dialect compatibility and safety.
     """
 
-    _table: "Optional[str]" = field(default=None, init=False)
+    __slots__ = ("_table",)
+    _expression: Optional[exp.Expression]
 
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize DELETE with optional table.
@@ -35,6 +35,7 @@ class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromCla
             **kwargs: Additional QueryBuilder arguments
         """
         super().__init__(**kwargs)
+        self._initialize_expression()
 
         self._table = None
 
@@ -69,8 +70,6 @@ class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromCla
         """
 
         if not self._table:
-            from sqlspec.exceptions import SQLBuilderError
-
             msg = "DELETE requires a table to be specified. Use from() to set the table."
             raise SQLBuilderError(msg)