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

sqlspec/{statement/builder/ddl.py → builder/_ddl.py}

@@ -1,4 +1,4 @@
-# DDL builders for SQLSpec: DROP, CREATE INDEX, TRUNCATE, etc.
+"""DDL builders for SQLSpec: DROP, CREATE INDEX, TRUNCATE, etc."""
 
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -7,13 +7,13 @@ from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 from typing_extensions import Self
 
-from sqlspec.statement.builder._ddl_utils import build_column_expression, build_constraint_expression
-from sqlspec.statement.builder.base import QueryBuilder, SafeQuery
-from sqlspec.statement.result import SQLResult
+from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder._ddl_utils import build_column_expression, build_constraint_expression
+from sqlspec.core.result import SQLResult
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.column import ColumnExpression
-    from sqlspec.statement.sql import SQL, SQLConfig
+    from sqlspec.builder._column import ColumnExpression
+    from sqlspec.core.statement import SQL, StatementConfig
 
 __all__ = (
     "AlterOperation",
@@ -33,28 +33,27 @@ __all__ = (
     "DropTable",
     "DropView",
     "RenameTable",
-    "TruncateTable",
+    "Truncate",
 )
 
 
 @dataclass
-class DDLBuilder(QueryBuilder[Any]):
+class DDLBuilder(QueryBuilder):
     """Base class for DDL builders (CREATE, DROP, ALTER, etc)."""
 
     dialect: DialectType = None
     _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
 
     def __post_init__(self) -> None:
-        # Override to prevent QueryBuilder from calling _create_base_expression prematurely
-        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."
         raise NotImplementedError(msg)
 
     @property
-    def _expected_result_type(self) -> "type[SQLResult[Any]]":
-        # DDL typically returns no rows; use object for now.
+    def _expected_result_type(self) -> "type[SQLResult]":
         return SQLResult
 
     def build(self) -> "SafeQuery":
@@ -62,11 +61,10 @@ class DDLBuilder(QueryBuilder[Any]):
             self._expression = self._create_base_expression()
         return super().build()
 
-    def to_statement(self, config: "Optional[SQLConfig]" = None) -> "SQL":
+    def to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
         return super().to_statement(config=config)
 
 
-# --- Data Structures for CREATE TABLE ---
 @dataclass
 class ColumnDefinition:
     """Column definition for CREATE TABLE."""
@@ -80,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
 
 
@@ -88,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
@@ -100,7 +98,6 @@ class ConstraintDefinition:
     initially_deferred: bool = False
 
 
-# --- CREATE TABLE ---
 @dataclass
 class CreateTable(DDLBuilder):
     """Builder for CREATE TABLE statements with columns and constraints.
@@ -201,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])
 
@@ -209,10 +205,8 @@ class CreateTable(DDLBuilder):
 
     def primary_key_constraint(self, columns: "Union[str, list[str]]", name: "Optional[str]" = None) -> "Self":
         """Add a primary key constraint."""
-        # Normalize column list
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
-        # Validation
         if not col_list:
             self._raise_sql_builder_error("Primary key must include at least one column")
 
@@ -239,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")
 
@@ -271,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:
@@ -289,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)
@@ -342,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):
@@ -362,16 +350,11 @@ class CreateTable(DDLBuilder):
         if self._tablespace:
             props.append(exp.Property(this=exp.to_identifier("TABLESPACE"), value=exp.to_identifier(self._tablespace)))
         if self._partition_by:
-            props.append(
-                exp.Property(this=exp.to_identifier("PARTITION BY"), value=exp.Literal.string(self._partition_by))
-            )
+            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 isinstance(value, str):
-                    props.append(exp.Property(this=exp.to_identifier(key.upper()), value=exp.Literal.string(value)))
-                else:
-                    props.append(exp.Property(this=exp.to_identifier(key.upper()), value=exp.Literal.number(value)))
+            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
 
@@ -402,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.
@@ -445,7 +427,6 @@ class DropTable(DDLBuilder):
         )
 
 
-# --- DROP INDEX ---
 @dataclass
 class DropIndex(DDLBuilder):
     """Builder for DROP INDEX [IF EXISTS] ... [ON table] [CASCADE|RESTRICT]."""
@@ -497,7 +478,6 @@ class DropIndex(DDLBuilder):
         )
 
 
-# --- DROP VIEW ---
 @dataclass
 class DropView(DDLBuilder):
     """Builder for DROP VIEW [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -530,7 +510,6 @@ class DropView(DDLBuilder):
         )
 
 
-# --- DROP SCHEMA ---
 @dataclass
 class DropSchema(DDLBuilder):
     """Builder for DROP SCHEMA [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -563,7 +542,6 @@ class DropSchema(DDLBuilder):
         )
 
 
-# --- CREATE INDEX ---
 @dataclass
 class CreateIndex(DDLBuilder):
     """Builder for CREATE [UNIQUE] INDEX [IF NOT EXISTS] ... ON ... (...).
@@ -588,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 = []
 
@@ -636,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),
@@ -649,14 +625,13 @@ class CreateIndex(DDLBuilder):
         )
 
 
-# --- TRUNCATE TABLE ---
 @dataclass
-class TruncateTable(DDLBuilder):
+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
@@ -685,7 +660,6 @@ class TruncateTable(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."""
@@ -702,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]."""
@@ -766,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
@@ -791,39 +764,32 @@ class CreateTableAsSelect(DDLBuilder):
             self._raise_sql_builder_error("SELECT query must be set for CREATE TABLE AS SELECT.")
 
         select_expr = None
-        select_params = None
-        from sqlspec.statement.builder.select import Select
-        from sqlspec.statement.sql import SQL
+        select_parameters = None
+        from sqlspec.builder._select import Select
+        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
-            select_params = getattr(self._select_query, "parameters", None)
+            select_parameters = getattr(self._select_query, "parameters", None)
         elif isinstance(self._select_query, Select):
             select_expr = getattr(self._select_query, "_expression", None)
-            select_params = getattr(self._select_query, "_parameters", None)
+            select_parameters = getattr(self._select_query, "_parameters", None)
 
             with_ctes = getattr(self._select_query, "_with_ctes", {})
             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_params = None
+            select_parameters = None
         else:
             self._raise_sql_builder_error("Unsupported type for SELECT query in CTAS.")
         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_params:
-            for p_name, p_value in select_params.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
+        if select_parameters:
+            for p_name, p_value in select_parameters.items():
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -849,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
@@ -908,29 +874,26 @@ class CreateMaterializedView(DDLBuilder):
             self._raise_sql_builder_error("SELECT query must be set for CREATE MATERIALIZED VIEW.")
 
         select_expr = None
-        select_params = None
-        from sqlspec.statement.builder.select import Select
-        from sqlspec.statement.sql import SQL
+        select_parameters = None
+        from sqlspec.builder._select import Select
+        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
-            select_params = getattr(self._select_query, "parameters", None)
+            select_parameters = getattr(self._select_query, "parameters", None)
         elif isinstance(self._select_query, Select):
             select_expr = getattr(self._select_query, "_expression", None)
-            select_params = getattr(self._select_query, "_parameters", None)
+            select_parameters = getattr(self._select_query, "_parameters", None)
         elif isinstance(self._select_query, str):
             select_expr = exp.maybe_parse(self._select_query)
-            select_params = None
+            select_parameters = None
         else:
             self._raise_sql_builder_error("Unsupported type for SELECT query in materialized view.")
         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_params:
-            for p_name, p_value in select_params.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
+        if select_parameters:
+            for p_name, p_value in select_parameters.items():
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -939,9 +902,7 @@ class CreateMaterializedView(DDLBuilder):
 
         props: list[exp.Property] = []
         if self._refresh_mode:
-            props.append(
-                exp.Property(this=exp.to_identifier("REFRESH_MODE"), value=exp.Literal.string(self._refresh_mode))
-            )
+            props.append(exp.Property(this=exp.to_identifier("REFRESH_MODE"), value=exp.convert(self._refresh_mode)))
         if self._tablespace:
             props.append(exp.Property(this=exp.to_identifier("TABLESPACE"), value=exp.to_identifier(self._tablespace)))
         if self._using_index:
@@ -949,12 +910,10 @@ class CreateMaterializedView(DDLBuilder):
                 exp.Property(this=exp.to_identifier("USING_INDEX"), value=exp.to_identifier(self._using_index))
             )
         for k, v in self._storage_parameters.items():
-            props.append(exp.Property(this=exp.to_identifier(k), value=exp.Literal.string(str(v))))
+            props.append(exp.Property(this=exp.to_identifier(k), value=exp.convert(str(v))))
         if self._with_data is not None:
             props.append(exp.Property(this=exp.to_identifier("WITH_DATA" if self._with_data else "NO_DATA")))
-        props.extend(
-            exp.Property(this=exp.to_identifier("HINT"), value=exp.Literal.string(hint)) for hint in self._hints
-        )
+        props.extend(exp.Property(this=exp.to_identifier("HINT"), value=exp.convert(hint)) for hint in self._hints)
         properties_node = exp.Properties(expressions=props) if props else None
 
         return exp.Create(
@@ -977,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:
@@ -1007,29 +966,26 @@ class CreateView(DDLBuilder):
             self._raise_sql_builder_error("SELECT query must be set for CREATE VIEW.")
 
         select_expr = None
-        select_params = None
-        from sqlspec.statement.builder.select import Select
-        from sqlspec.statement.sql import SQL
+        select_parameters = None
+        from sqlspec.builder._select import Select
+        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
-            select_params = getattr(self._select_query, "parameters", None)
+            select_parameters = getattr(self._select_query, "parameters", None)
         elif isinstance(self._select_query, Select):
             select_expr = getattr(self._select_query, "_expression", None)
-            select_params = getattr(self._select_query, "_parameters", None)
+            select_parameters = getattr(self._select_query, "_parameters", None)
         elif isinstance(self._select_query, str):
             select_expr = exp.maybe_parse(self._select_query)
-            select_params = None
+            select_parameters = None
         else:
             self._raise_sql_builder_error("Unsupported type for SELECT query in view.")
         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_params:
-            for p_name, p_value in select_params.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
+        if select_parameters:
+            for p_name, p_value in select_parameters.items():
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -1037,7 +993,7 @@ class CreateView(DDLBuilder):
             schema_expr = exp.Schema(expressions=[exp.column(c) for c in self._columns])
 
         props: list[exp.Property] = [
-            exp.Property(this=exp.to_identifier("HINT"), value=exp.Literal.string(h)) for h in self._hints
+            exp.Property(this=exp.to_identifier("HINT"), value=exp.convert(h)) for h in self._hints
         ]
         properties_node = exp.Properties(expressions=props) if props else None
 
@@ -1177,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"):
@@ -1238,24 +1191,6 @@ class AlterTable(DDLBuilder):
         self._operations.append(operation)
         return self
 
-    def set_default(self, column: str, default: "Any") -> "Self":
-        """Set default value for a column."""
-        operation = AlterOperation(
-            operation_type="ALTER COLUMN SET DEFAULT",
-            column_name=column,
-            column_definition=ColumnDefinition(name=column, dtype="", default=default),
-        )
-
-        self._operations.append(operation)
-        return self
-
-    def drop_default(self, column: str) -> "Self":
-        """Remove default value from a column."""
-        operation = AlterOperation(operation_type="ALTER COLUMN DROP DEFAULT", column_name=column)
-
-        self._operations.append(operation)
-        return self
-
     def _create_base_expression(self) -> "exp.Expression":
         """Create the SQLGlot expression for ALTER TABLE."""
         if not self._operations:
@@ -1277,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":
@@ -1327,22 +1259,22 @@ class AlterTable(DDLBuilder):
                 if default_val.upper() in {"CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME"} or "(" in default_val:
                     default_expr = exp.maybe_parse(default_val)
                 else:
-                    default_expr = exp.Literal.string(default_val)
+                    default_expr = exp.convert(default_val)
             elif isinstance(default_val, (int, float)):
-                default_expr = exp.Literal.number(default_val)
+                default_expr = exp.convert(default_val)
             elif default_val is True:
                 default_expr = exp.true()
             elif default_val is False:
                 default_expr = exp.false()
             else:
-                default_expr = exp.Literal.string(str(default_val))
+                default_expr = exp.convert(str(default_val))
             return exp.AlterColumn(this=exp.to_identifier(op.column_name), default=default_expr)
 
         if op_type == "ALTER COLUMN DROP DEFAULT":
             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
@@ -1352,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
@@ -1375,17 +1307,15 @@ class CommentOn(DDLBuilder):
 
     def _create_base_expression(self) -> exp.Expression:
         if self._target_type == "TABLE" and self._table and self._comment is not None:
-            return exp.Comment(
-                this=exp.to_table(self._table), kind="TABLE", expression=exp.Literal.string(self._comment)
-            )
+            return exp.Comment(this=exp.to_table(self._table), kind="TABLE", expression=exp.convert(self._comment))
         if self._target_type == "COLUMN" and self._table and self._column and self._comment is not None:
             return exp.Comment(
                 this=exp.Column(table=self._table, this=self._column),
                 kind="COLUMN",
-                expression=exp.Literal.string(self._comment),
+                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/{statement/builder → builder}/_ddl_utils.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Optional
 from sqlglot import exp
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.ddl import ColumnDefinition, ConstraintDefinition
+    from sqlspec.builder._ddl import ColumnDefinition, ConstraintDefinition
 
 __all__ = ("build_column_expression", "build_constraint_expression")
 
@@ -31,15 +31,9 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
             if col.default.upper() in {"CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME"} or "(" in col.default:
                 default_expr = exp.maybe_parse(col.default)
             else:
-                default_expr = exp.Literal.string(col.default)
-        elif isinstance(col.default, (int, float)):
-            default_expr = exp.Literal.number(col.default)
-        elif col.default is True:
-            default_expr = exp.true()
-        elif col.default is False:
-            default_expr = exp.false()
+                default_expr = exp.convert(col.default)
         else:
-            default_expr = exp.Literal.string(str(col.default))
+            default_expr = exp.convert(col.default)
 
         constraints.append(exp.ColumnConstraint(kind=default_expr))
 
@@ -48,7 +42,7 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
         constraints.append(exp.ColumnConstraint(kind=check_expr))
 
     if col.comment:
-        constraints.append(exp.ColumnConstraint(kind=exp.CommentColumnConstraint(this=exp.Literal.string(col.comment))))
+        constraints.append(exp.ColumnConstraint(kind=exp.CommentColumnConstraint(this=exp.convert(col.comment))))
 
     if col.generated:
         generated_expr = exp.GeneratedAsIdentityColumnConstraint(this=exp.maybe_parse(col.generated))