sqlspec 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

sqlspec/builder/_ddl.py

@@ -4,19 +4,21 @@ Provides builders for DDL operations including CREATE, DROP, ALTER,
 TRUNCATE, and other schema manipulation statements.
 """
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 from typing_extensions import Self
 
 from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder._select import Select
 from sqlspec.core.result import SQLResult
+from sqlspec.core.statement import SQL
 from sqlspec.utils.type_guards import has_sqlglot_expression, has_with_method
 
 if TYPE_CHECKING:
     from sqlspec.builder._column import ColumnExpression
-    from sqlspec.core.statement import SQL, StatementConfig
+    from sqlspec.core.statement import StatementConfig
 
 __all__ = (
     "AlterOperation",
@@ -39,6 +41,37 @@ __all__ = (
     "Truncate",
 )
 
+CONSTRAINT_TYPE_PRIMARY_KEY = "PRIMARY KEY"
+CONSTRAINT_TYPE_FOREIGN_KEY = "FOREIGN KEY"
+CONSTRAINT_TYPE_UNIQUE = "UNIQUE"
+CONSTRAINT_TYPE_CHECK = "CHECK"
+
+FOREIGN_KEY_ACTION_CASCADE = "CASCADE"
+FOREIGN_KEY_ACTION_SET_NULL = "SET NULL"
+FOREIGN_KEY_ACTION_SET_DEFAULT = "SET DEFAULT"
+FOREIGN_KEY_ACTION_RESTRICT = "RESTRICT"
+FOREIGN_KEY_ACTION_NO_ACTION = "NO ACTION"
+
+VALID_FOREIGN_KEY_ACTIONS = {
+    FOREIGN_KEY_ACTION_CASCADE,
+    FOREIGN_KEY_ACTION_SET_NULL,
+    FOREIGN_KEY_ACTION_SET_DEFAULT,
+    FOREIGN_KEY_ACTION_RESTRICT,
+    FOREIGN_KEY_ACTION_NO_ACTION,
+    None,
+}
+
+VALID_CONSTRAINT_TYPES = {
+    CONSTRAINT_TYPE_PRIMARY_KEY,
+    CONSTRAINT_TYPE_FOREIGN_KEY,
+    CONSTRAINT_TYPE_UNIQUE,
+    CONSTRAINT_TYPE_CHECK,
+}
+
+CURRENT_TIMESTAMP_KEYWORD = "CURRENT_TIMESTAMP"
+CURRENT_DATE_KEYWORD = "CURRENT_DATE"
+CURRENT_TIME_KEYWORD = "CURRENT_TIME"
+
 
 def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
     """Build SQLGlot expression for a column definition."""
@@ -56,14 +89,14 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
         constraints.append(exp.ColumnConstraint(kind=exp.UniqueColumnConstraint()))
 
     if col.default is not None:
-        default_expr: Optional[exp.Expression] = None
+        default_expr: exp.Expression | None = None
         if isinstance(col.default, str):
             default_upper = col.default.upper()
-            if default_upper == "CURRENT_TIMESTAMP":
+            if default_upper == CURRENT_TIMESTAMP_KEYWORD:
                 default_expr = exp.CurrentTimestamp()
-            elif default_upper == "CURRENT_DATE":
+            elif default_upper == CURRENT_DATE_KEYWORD:
                 default_expr = exp.CurrentDate()
-            elif default_upper == "CURRENT_TIME":
+            elif default_upper == CURRENT_TIME_KEYWORD:
                 default_expr = exp.CurrentTime()
             elif "(" in col.default:
                 default_expr = exp.maybe_parse(col.default)
@@ -94,16 +127,16 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
     return col_def
 
 
-def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional[exp.Expression]":
+def build_constraint_expression(constraint: "ConstraintDefinition") -> "exp.Expression | None":
     """Build SQLGlot expression for a table constraint."""
-    if constraint.constraint_type == "PRIMARY KEY":
+    if constraint.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY:
         pk_constraint = exp.PrimaryKey(expressions=[exp.to_identifier(col) for col in constraint.columns])
 
         if constraint.name:
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=pk_constraint)
         return pk_constraint
 
-    if constraint.constraint_type == "FOREIGN KEY":
+    if constraint.constraint_type == CONSTRAINT_TYPE_FOREIGN_KEY:
         fk_constraint = exp.ForeignKey(
             expressions=[exp.to_identifier(col) for col in constraint.columns],
             reference=exp.Reference(
@@ -118,14 +151,14 @@ def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=fk_constraint)
         return fk_constraint
 
-    if constraint.constraint_type == "UNIQUE":
+    if constraint.constraint_type == CONSTRAINT_TYPE_UNIQUE:
         unique_constraint = exp.UniqueKeyProperty(expressions=[exp.to_identifier(col) for col in constraint.columns])
 
         if constraint.name:
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=unique_constraint)
         return unique_constraint
 
-    if constraint.constraint_type == "CHECK":
+    if constraint.constraint_type == CONSTRAINT_TYPE_CHECK:
         check_expr = exp.Check(this=exp.maybe_parse(constraint.condition) if constraint.condition else None)
 
         if constraint.name:
@@ -142,7 +175,7 @@ class DDLBuilder(QueryBuilder):
 
     def __init__(self, dialect: DialectType = None) -> None:
         super().__init__(dialect=dialect)
-        self._expression: Optional[exp.Expression] = None
+        self._expression: exp.Expression | None = None
 
     def _create_base_expression(self) -> exp.Expression:
         msg = "Subclasses must implement _create_base_expression."
@@ -157,7 +190,7 @@ class DDLBuilder(QueryBuilder):
             self._expression = self._create_base_expression()
         return super().build()
 
-    def to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
+    def to_statement(self, config: "StatementConfig | None" = None) -> "SQL":
         return super().to_statement(config=config)
 
 
@@ -182,15 +215,15 @@ class ColumnDefinition:
         self,
         name: str,
         dtype: str,
-        default: "Optional[Any]" = None,
+        default: "Any | None" = None,
         not_null: bool = False,
         primary_key: bool = False,
         unique: bool = False,
         auto_increment: bool = False,
-        comment: "Optional[str]" = None,
-        check: "Optional[str]" = None,
-        generated: "Optional[str]" = None,
-        collate: "Optional[str]" = None,
+        comment: "str | None" = None,
+        check: "str | None" = None,
+        generated: "str | None" = None,
+        collate: "str | None" = None,
     ) -> None:
         self.name = name
         self.dtype = dtype
@@ -224,13 +257,13 @@ class ConstraintDefinition:
     def __init__(
         self,
         constraint_type: str,
-        name: "Optional[str]" = None,
-        columns: "Optional[list[str]]" = None,
-        references_table: "Optional[str]" = None,
-        references_columns: "Optional[list[str]]" = None,
-        condition: "Optional[str]" = None,
-        on_delete: "Optional[str]" = None,
-        on_update: "Optional[str]" = None,
+        name: "str | None" = None,
+        columns: "list[str] | None" = None,
+        references_table: "str | None" = None,
+        references_columns: "list[str] | None" = None,
+        condition: "str | None" = None,
+        on_delete: "str | None" = None,
+        on_update: "str | None" = None,
         deferrable: bool = False,
         initially_deferred: bool = False,
     ) -> None:
@@ -281,10 +314,10 @@ class CreateTable(DDLBuilder):
         self._columns: list[ColumnDefinition] = []
         self._constraints: list[ConstraintDefinition] = []
         self._table_options: dict[str, Any] = {}
-        self._schema: Optional[str] = None
-        self._tablespace: Optional[str] = None
-        self._like_table: Optional[str] = None
-        self._partition_by: Optional[str] = None
+        self._schema: str | None = None
+        self._tablespace: str | None = None
+        self._like_table: str | None = None
+        self._partition_by: str | None = None
 
     def in_schema(self, schema_name: str) -> "Self":
         """Set the schema for the table."""
@@ -316,19 +349,28 @@ class CreateTable(DDLBuilder):
         self._partition_by = partition_spec
         return self
 
+    @property
+    def columns(self) -> "list[ColumnDefinition]":
+        """Get the list of column definitions for this table.
+
+        Returns:
+            List of ColumnDefinition objects.
+        """
+        return self._columns
+
     def column(
         self,
         name: str,
         dtype: str,
-        default: "Optional[Any]" = None,
+        default: "Any | None" = None,
         not_null: bool = False,
         primary_key: bool = False,
         unique: bool = False,
         auto_increment: bool = False,
-        comment: "Optional[str]" = None,
-        check: "Optional[str]" = None,
-        generated: "Optional[str]" = None,
-        collate: "Optional[str]" = None,
+        comment: "str | None" = None,
+        check: "str | None" = None,
+        generated: "str | None" = None,
+        collate: "str | None" = None,
     ) -> "Self":
         """Add a column definition to the table."""
         if not name:
@@ -356,37 +398,37 @@ class CreateTable(DDLBuilder):
 
         self._columns.append(column_def)
 
-        if primary_key and not any(c.constraint_type == "PRIMARY KEY" for c in self._constraints):
+        if primary_key and not self._has_primary_key_constraint():
             self.primary_key_constraint([name])
 
         return self
 
-    def primary_key_constraint(self, columns: "Union[str, list[str]]", name: "Optional[str]" = None) -> "Self":
+    def primary_key_constraint(self, columns: "str | list[str]", name: "str | None" = None) -> "Self":
         """Add a primary key constraint."""
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         if not col_list:
             self._raise_sql_builder_error("Primary key must include at least one column")
 
-        existing_pk = next((c for c in self._constraints if c.constraint_type == "PRIMARY KEY"), None)
+        existing_pk = self._find_primary_key_constraint()
         if existing_pk:
             for col in col_list:
                 if col not in existing_pk.columns:
                     existing_pk.columns.append(col)
         else:
-            constraint = ConstraintDefinition(constraint_type="PRIMARY KEY", name=name, columns=col_list)
+            constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_PRIMARY_KEY, name=name, columns=col_list)
             self._constraints.append(constraint)
 
         return self
 
     def foreign_key_constraint(
         self,
-        columns: "Union[str, list[str]]",
+        columns: "str | list[str]",
         references_table: str,
-        references_columns: "Union[str, list[str]]",
-        name: "Optional[str]" = None,
-        on_delete: "Optional[str]" = None,
-        on_update: "Optional[str]" = None,
+        references_columns: "str | list[str]",
+        name: "str | None" = None,
+        on_delete: "str | None" = None,
+        on_update: "str | None" = None,
         deferrable: bool = False,
         initially_deferred: bool = False,
     ) -> "Self":
@@ -398,14 +440,11 @@ class CreateTable(DDLBuilder):
         if len(col_list) != len(ref_col_list):
             self._raise_sql_builder_error("Foreign key columns and referenced columns must have same length")
 
-        valid_actions = {"CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION", None}
-        if on_delete and on_delete.upper() not in valid_actions:
-            self._raise_sql_builder_error(f"Invalid ON DELETE action: {on_delete}")
-        if on_update and on_update.upper() not in valid_actions:
-            self._raise_sql_builder_error(f"Invalid ON UPDATE action: {on_update}")
+        self._validate_foreign_key_action(on_delete, "ON DELETE")
+        self._validate_foreign_key_action(on_update, "ON UPDATE")
 
         constraint = ConstraintDefinition(
-            constraint_type="FOREIGN KEY",
+            constraint_type=CONSTRAINT_TYPE_FOREIGN_KEY,
             name=name,
             columns=col_list,
             references_table=references_table,
@@ -419,19 +458,19 @@ class CreateTable(DDLBuilder):
         self._constraints.append(constraint)
         return self
 
-    def unique_constraint(self, columns: "Union[str, list[str]]", name: "Optional[str]" = None) -> "Self":
+    def unique_constraint(self, columns: "str | list[str]", name: "str | None" = None) -> "Self":
         """Add a unique constraint."""
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         if not col_list:
             self._raise_sql_builder_error("Unique constraint must include at least one column")
 
-        constraint = ConstraintDefinition(constraint_type="UNIQUE", name=name, columns=col_list)
+        constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_UNIQUE, name=name, columns=col_list)
 
         self._constraints.append(constraint)
         return self
 
-    def check_constraint(self, condition: Union[str, "ColumnExpression"], name: "Optional[str]" = None) -> "Self":
+    def check_constraint(self, condition: Union[str, "ColumnExpression"], name: "str | None" = None) -> "Self":
         """Add a check constraint."""
         if not condition:
             self._raise_sql_builder_error("Check constraint must have a condition")
@@ -443,7 +482,7 @@ class CreateTable(DDLBuilder):
         else:
             condition_str = str(condition)
 
-        constraint = ConstraintDefinition(constraint_type="CHECK", name=name, condition=condition_str)
+        constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_CHECK, name=name, condition=condition_str)
 
         self._constraints.append(constraint)
         return self
@@ -484,10 +523,8 @@ class CreateTable(DDLBuilder):
             column_defs.append(col_expr)
 
         for constraint in self._constraints:
-            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):
-                    continue
+            if self._is_redundant_single_column_primary_key(constraint):
+                continue
 
             constraint_expr = build_constraint_expression(constraint)
             if constraint_expr:
@@ -531,6 +568,27 @@ class CreateTable(DDLBuilder):
             like=like_expr,
         )
 
+    def _has_primary_key_constraint(self) -> bool:
+        """Check if table already has a primary key constraint."""
+        return any(c.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY for c in self._constraints)
+
+    def _find_primary_key_constraint(self) -> "ConstraintDefinition | None":
+        """Find existing primary key constraint."""
+        return next((c for c in self._constraints if c.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY), None)
+
+    def _validate_foreign_key_action(self, action: "str | None", action_type: str) -> None:
+        """Validate foreign key action (ON DELETE or ON UPDATE)."""
+        if action and action.upper() not in VALID_FOREIGN_KEY_ACTIONS:
+            self._raise_sql_builder_error(f"Invalid {action_type} action: {action}")
+
+    def _is_redundant_single_column_primary_key(self, constraint: "ConstraintDefinition") -> bool:
+        """Check if constraint is a redundant single-column primary key."""
+        if constraint.constraint_type != CONSTRAINT_TYPE_PRIMARY_KEY or len(constraint.columns) != 1:
+            return False
+
+        col_name = constraint.columns[0]
+        return any(c.name == col_name and c.primary_key for c in self._columns)
+
 
 class DropTable(DDLBuilder):
     """Builder for DROP TABLE [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -547,7 +605,7 @@ class DropTable(DDLBuilder):
         super().__init__(dialect=dialect)
         self._table_name = table_name
         self._if_exists = False
-        self._cascade: Optional[bool] = None
+        self._cascade: bool | None = None
 
     def table(self, name: str) -> Self:
         self._table_name = name
@@ -587,9 +645,9 @@ class DropIndex(DDLBuilder):
         """
         super().__init__(dialect=dialect)
         self._index_name = index_name
-        self._table_name: Optional[str] = None
+        self._table_name: str | None = None
         self._if_exists = False
-        self._cascade: Optional[bool] = None
+        self._cascade: bool | None = None
 
     def name(self, index_name: str) -> Self:
         self._index_name = index_name
@@ -638,7 +696,7 @@ class DropView(DDLBuilder):
         super().__init__(dialect=dialect)
         self._view_name = view_name
         self._if_exists = False
-        self._cascade: Optional[bool] = None
+        self._cascade: bool | None = None
 
     def name(self, view_name: str) -> Self:
         self._view_name = view_name
@@ -679,7 +737,7 @@ class DropSchema(DDLBuilder):
         super().__init__(dialect=dialect)
         self._schema_name = schema_name
         self._if_exists = False
-        self._cascade: Optional[bool] = None
+        self._cascade: bool | None = None
 
     def name(self, schema_name: str) -> Self:
         self._schema_name = schema_name
@@ -719,12 +777,12 @@ class CreateIndex(DDLBuilder):
         """
         super().__init__(dialect=dialect)
         self._index_name = index_name
-        self._table_name: Optional[str] = None
-        self._columns: list[Union[str, exp.Ordered, exp.Expression]] = []
+        self._table_name: str | None = None
+        self._columns: list[str | exp.Ordered | exp.Expression] = []
         self._unique = False
         self._if_not_exists = False
-        self._using: Optional[str] = None
-        self._where: Optional[Union[str, exp.Expression]] = None
+        self._using: str | None = None
+        self._where: str | exp.Expression | None = None
 
     def name(self, index_name: str) -> Self:
         self._index_name = index_name
@@ -734,11 +792,11 @@ class CreateIndex(DDLBuilder):
         self._table_name = table_name
         return self
 
-    def columns(self, *cols: Union[str, exp.Ordered, exp.Expression]) -> Self:
+    def columns(self, *cols: str | exp.Ordered | exp.Expression) -> Self:
         self._columns.extend(cols)
         return self
 
-    def expressions(self, *exprs: Union[str, exp.Expression]) -> Self:
+    def expressions(self, *exprs: str | exp.Expression) -> Self:
         self._columns.extend(exprs)
         return self
 
@@ -754,7 +812,7 @@ class CreateIndex(DDLBuilder):
         self._using = method
         return self
 
-    def where(self, condition: Union[str, exp.Expression]) -> Self:
+    def where(self, condition: str | exp.Expression) -> Self:
         self._where = condition
         return self
 
@@ -796,8 +854,8 @@ class Truncate(DDLBuilder):
         """
         super().__init__(dialect=dialect)
         self._table_name = table_name
-        self._cascade: Optional[bool] = None
-        self._identity: Optional[str] = None
+        self._cascade: bool | None = None
+        self._identity: str | None = None
 
     def table(self, name: str) -> Self:
         self._table_name = name
@@ -845,15 +903,15 @@ class AlterOperation:
     def __init__(
         self,
         operation_type: str,
-        column_name: "Optional[str]" = None,
-        column_definition: "Optional[ColumnDefinition]" = None,
-        constraint_name: "Optional[str]" = None,
-        constraint_definition: "Optional[ConstraintDefinition]" = None,
-        new_type: "Optional[str]" = None,
-        new_name: "Optional[str]" = None,
-        after_column: "Optional[str]" = None,
+        column_name: "str | None" = None,
+        column_definition: "ColumnDefinition | None" = None,
+        constraint_name: "str | None" = None,
+        constraint_definition: "ConstraintDefinition | None" = None,
+        new_type: "str | None" = None,
+        new_name: "str | None" = None,
+        after_column: "str | None" = None,
         first: bool = False,
-        using_expression: "Optional[str]" = None,
+        using_expression: "str | None" = None,
     ) -> None:
         self.operation_type = operation_type
         self.column_name = column_name
@@ -882,7 +940,7 @@ class CreateSchema(DDLBuilder):
         super().__init__(dialect=dialect)
         self._schema_name = schema_name
         self._if_not_exists = False
-        self._authorization: Optional[str] = None
+        self._authorization: str | None = None
 
     def name(self, schema_name: str) -> Self:
         self._schema_name = schema_name
@@ -937,10 +995,10 @@ class CreateTableAsSelect(DDLBuilder):
 
     def __init__(self, dialect: DialectType = None) -> None:
         super().__init__(dialect=dialect)
-        self._table_name: Optional[str] = None
+        self._table_name: str | None = None
         self._if_not_exists = False
         self._columns: list[str] = []
-        self._select_query: Optional[object] = None
+        self._select_query: object | None = None
 
     def name(self, table_name: str) -> Self:
         self._table_name = table_name
@@ -954,7 +1012,7 @@ class CreateTableAsSelect(DDLBuilder):
         self._columns = list(cols)
         return self
 
-    def as_select(self, select_query: "Union[str, exp.Expression]") -> Self:
+    def as_select(self, select_query: "str | exp.Expression") -> Self:
         self._select_query = select_query
         return self
 
@@ -966,8 +1024,6 @@ class CreateTableAsSelect(DDLBuilder):
 
         select_expr = None
         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
@@ -1033,12 +1089,12 @@ class CreateMaterializedView(DDLBuilder):
         self._view_name = view_name
         self._if_not_exists = False
         self._columns: list[str] = []
-        self._select_query: Optional[Union[str, exp.Expression]] = None
-        self._with_data: Optional[bool] = None
-        self._refresh_mode: Optional[str] = None
+        self._select_query: str | exp.Expression | None = None
+        self._with_data: bool | None = None
+        self._refresh_mode: str | None = None
         self._storage_parameters: dict[str, Any] = {}
-        self._tablespace: Optional[str] = None
-        self._using_index: Optional[str] = None
+        self._tablespace: str | None = None
+        self._using_index: str | None = None
         self._hints: list[str] = []
 
     def name(self, view_name: str) -> Self:
@@ -1053,7 +1109,7 @@ class CreateMaterializedView(DDLBuilder):
         self._columns = list(cols)
         return self
 
-    def as_select(self, select_query: "Union[str, exp.Expression]") -> Self:
+    def as_select(self, select_query: "str | exp.Expression") -> Self:
         self._select_query = select_query
         return self
 
@@ -1093,8 +1149,6 @@ class CreateMaterializedView(DDLBuilder):
 
         select_expr = None
         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
@@ -1160,7 +1214,7 @@ class CreateView(DDLBuilder):
         self._view_name = view_name
         self._if_not_exists = False
         self._columns: list[str] = []
-        self._select_query: Optional[Union[str, exp.Expression]] = None
+        self._select_query: str | exp.Expression | None = None
         self._hints: list[str] = []
 
     def name(self, view_name: str) -> Self:
@@ -1175,7 +1229,7 @@ class CreateView(DDLBuilder):
         self._columns = list(cols)
         return self
 
-    def as_select(self, select_query: "Union[str, exp.Expression]") -> Self:
+    def as_select(self, select_query: "str | exp.Expression") -> Self:
         self._select_query = select_query
         return self
 
@@ -1191,8 +1245,6 @@ class CreateView(DDLBuilder):
 
         select_expr = None
         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
@@ -1249,7 +1301,7 @@ class AlterTable(DDLBuilder):
         super().__init__(dialect=dialect)
         self._table_name = table_name
         self._operations: list[AlterOperation] = []
-        self._schema: Optional[str] = None
+        self._schema: str | None = None
         self._if_exists = False
 
     def if_exists(self) -> "Self":
@@ -1261,11 +1313,11 @@ class AlterTable(DDLBuilder):
         self,
         name: str,
         dtype: str,
-        default: "Optional[Any]" = None,
+        default: "Any | None" = None,
         not_null: bool = False,
         unique: bool = False,
-        comment: "Optional[str]" = None,
-        after: "Optional[str]" = None,
+        comment: "str | None" = None,
+        after: "str | None" = None,
         first: bool = False,
     ) -> "Self":
         """Add a new column to the table."""
@@ -1296,7 +1348,7 @@ class AlterTable(DDLBuilder):
         self._operations.append(operation)
         return self
 
-    def alter_column_type(self, name: str, new_type: str, using: "Optional[str]" = None) -> "Self":
+    def alter_column_type(self, name: str, new_type: str, using: "str | None" = None) -> "Self":
         """Change the type of an existing column."""
         if not name:
             self._raise_sql_builder_error("Column name must be a non-empty string")
@@ -1327,13 +1379,13 @@ class AlterTable(DDLBuilder):
     def add_constraint(
         self,
         constraint_type: str,
-        columns: "Optional[Union[str, list[str]]]" = None,
-        name: "Optional[str]" = None,
-        references_table: "Optional[str]" = None,
-        references_columns: "Optional[Union[str, list[str]]]" = None,
-        condition: "Optional[Union[str, ColumnExpression]]" = None,
-        on_delete: "Optional[str]" = None,
-        on_update: "Optional[str]" = None,
+        columns: "str | list[str] | None" = None,
+        name: "str | None" = None,
+        references_table: "str | None" = None,
+        references_columns: "str | list[str] | None" = None,
+        condition: "str | ColumnExpression | None" = None,
+        on_delete: "str | None" = None,
+        on_update: "str | None" = None,
     ) -> "Self":
         """Add a constraint to the table.
 
@@ -1347,8 +1399,7 @@ class AlterTable(DDLBuilder):
             on_delete: Foreign key ON DELETE action
             on_update: Foreign key ON UPDATE action
         """
-        valid_types = {"PRIMARY KEY", "FOREIGN KEY", "UNIQUE", "CHECK"}
-        if constraint_type.upper() not in valid_types:
+        if constraint_type.upper() not in VALID_CONSTRAINT_TYPES:
             self._raise_sql_builder_error(f"Invalid constraint type: {constraint_type}")
 
         col_list = None
@@ -1359,10 +1410,10 @@ class AlterTable(DDLBuilder):
         if references_columns is not None:
             ref_col_list = [references_columns] if isinstance(references_columns, str) else list(references_columns)
 
-        condition_str: Optional[str] = None
+        condition_str: str | None = None
         if condition is not None:
-            if hasattr(condition, "sqlglot_expression"):
-                sqlglot_expr = getattr(condition, "sqlglot_expression", None)
+            if has_sqlglot_expression(condition):
+                sqlglot_expr = condition.sqlglot_expression
                 condition_str = sqlglot_expr.sql(dialect=self.dialect) if sqlglot_expr else str(condition)
             else:
                 condition_str = str(condition)
@@ -1472,9 +1523,9 @@ class AlterTable(DDLBuilder):
             if not op.column_definition or op.column_definition.default is None:
                 self._raise_sql_builder_error("Default value required for SET DEFAULT")
             default_val = op.column_definition.default
-            default_expr: Optional[exp.Expression]
+            default_expr: exp.Expression | None
             if isinstance(default_val, str):
-                if default_val.upper() in {"CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME"} or "(" in default_val:
+                if self._is_sql_function_default(default_val):
                     default_expr = exp.maybe_parse(default_val)
                 else:
                     default_expr = exp.convert(default_val)
@@ -1494,6 +1545,14 @@ class AlterTable(DDLBuilder):
         self._raise_sql_builder_error(f"Unknown operation type: {op.operation_type}")
         raise AssertionError
 
+    def _is_sql_function_default(self, default_val: str) -> bool:
+        """Check if default value is a SQL function or expression."""
+        default_upper = default_val.upper()
+        return (
+            default_upper in {CURRENT_TIMESTAMP_KEYWORD, CURRENT_DATE_KEYWORD, CURRENT_TIME_KEYWORD}
+            or "(" in default_val
+        )
+
 
 class CommentOn(DDLBuilder):
     """Builder for COMMENT ON ... IS ... statements."""
@@ -1507,10 +1566,10 @@ class CommentOn(DDLBuilder):
             dialect: SQL dialect to use
         """
         super().__init__(dialect=dialect)
-        self._target_type: Optional[str] = None
-        self._table: Optional[str] = None
-        self._column: Optional[str] = None
-        self._comment: Optional[str] = None
+        self._target_type: str | None = None
+        self._table: str | None = None
+        self._column: str | None = None
+        self._comment: str | None = None
 
     def on_table(self, table: str) -> Self:
         self._target_type = "TABLE"
@@ -1555,7 +1614,7 @@ class RenameTable(DDLBuilder):
         """
         super().__init__(dialect=dialect)
         self._old_name = old_name
-        self._new_name: Optional[str] = None
+        self._new_name: str | None = None
 
     def table(self, old_name: str) -> Self:
         self._old_name = old_name