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

sqlspec/{statement/builder → builder}/_parsing_utils.py

@@ -32,7 +32,6 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
     if isinstance(column_input, exp.Expression):
         return column_input
 
-    # Handle our custom Column objects
     if has_expression_attr(column_input):
         attr_value = getattr(column_input, "_expression", None)
         if isinstance(attr_value, exp.Expression):
@@ -44,7 +43,6 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
 def parse_table_expression(table_input: str, explicit_alias: Optional[str] = None) -> exp.Expression:
     """Parses a table string that can be a name, a name with an alias, or a subquery string."""
     with contextlib.suppress(Exception):
-        # Wrapping in a SELECT statement is a robust way to parse various table-like syntaxes
         parsed = parse_one(f"SELECT * FROM {table_input}")
         if isinstance(parsed, exp.Select) and parsed.args.get("from"):
             from_clause = cast("exp.From", parsed.args.get("from"))
@@ -110,33 +108,32 @@ def parse_condition_expression(
         column_expr = parse_column_expression(column)
         if value is None:
             return exp.Is(this=column_expr, expression=exp.null())
-        # Use builder's parameter system if available
         if builder and has_parameter_builder(builder):
-            _, param_name = builder.add_parameter(value)
+            from sqlspec.builder.mixins._where_clause import _extract_column_name
+
+            column_name = _extract_column_name(column)
+            param_name = builder._generate_unique_parameter_name(column_name)
+            _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_expr, expression=exp.Placeholder(this=param_name))
         if isinstance(value, str):
-            return exp.EQ(this=column_expr, expression=exp.Literal.string(value))
+            return exp.EQ(this=column_expr, expression=exp.convert(value))
         if isinstance(value, (int, float)):
-            return exp.EQ(this=column_expr, expression=exp.Literal.number(str(value)))
-        return exp.EQ(this=column_expr, expression=exp.Literal.string(str(value)))
+            return exp.EQ(this=column_expr, expression=exp.convert(str(value)))
+        return exp.EQ(this=column_expr, expression=exp.convert(str(value)))
 
     if not isinstance(condition_input, str):
         condition_input = str(condition_input)
 
     try:
-        # Parse as condition using SQLGlot's condition parser
         return exp.condition(condition_input)
     except Exception:
-        # If that fails, try parsing as a general expression
         try:
             parsed = exp.maybe_parse(condition_input)  # type: ignore[var-annotated]
             if parsed:
                 return parsed  # type:ignore[no-any-return]
         except Exception:  # noqa: S110
-            # SQLGlot condition parsing failed, will use raw condition
             pass
 
-    # Ultimate fallback: treat as raw condition string
     return exp.condition(condition_input)
 
 

sqlspec/{statement/builder → builder}/_select.py

@@ -6,13 +6,13 @@ with automatic parameter binding and validation.
 
 import re
 from dataclasses import dataclass, field
-from typing import Any, Optional, Union, cast
+from typing import Any, Optional, Union
 
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.statement.builder._base import QueryBuilder, SafeQuery
-from sqlspec.statement.builder.mixins import (
+from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder.mixins import (
     CommonTableExpressionMixin,
     HavingClauseMixin,
     JoinClauseMixin,
@@ -24,19 +24,17 @@ from sqlspec.statement.builder.mixins import (
     UnpivotClauseMixin,
     WhereClauseMixin,
 )
-from sqlspec.statement.result import SQLResult
-from sqlspec.typing import RowT
+from sqlspec.core.result import SQLResult
 
 __all__ = ("Select",)
 
 
-# This pattern is formatted with the table name and compiled for each hint.
 TABLE_HINT_PATTERN = r"\b{}\b(\s+AS\s+\w+)?"
 
 
 @dataclass
 class Select(
-    QueryBuilder[RowT],
+    QueryBuilder,
     WhereClauseMixin,
     OrderByClauseMixin,
     LimitOffsetClauseMixin,
@@ -51,29 +49,17 @@ class Select(
     """Type-safe builder for SELECT queries with schema/model integration.
 
     This builder provides a fluent, safe interface for constructing SQL SELECT statements.
-    It supports type-safe result mapping via the `as_schema()` method, allowing users to
-    associate a schema/model (such as a Pydantic model, dataclass, or msgspec.Struct) with
-    the query for static type checking and IDE support.
 
     Example:
         >>> class User(BaseModel):
         ...     id: int
         ...     name: str
-        >>> builder = (
-        ...     SelectBuilder()
-        ...     .select("id", "name")
-        ...     .from_("users")
-        ...     .as_schema(User)
-        ... )
-        >>> result: list[User] = driver.execute(builder)
-
-    Attributes:
-        _schema: The schema/model class for row typing, if set via as_schema().
+        >>> builder = Select("id", "name").from_("users")
+        >>> result = driver.execute(builder)
     """
 
     _with_parts: "dict[str, Union[exp.CTE, Select]]" = field(default_factory=dict, init=False)
     _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
-    _schema: Optional[type[RowT]] = None
     _hints: "list[dict[str, object]]" = field(default_factory=list, init=False, repr=False)
 
     def __init__(self, *columns: str, **kwargs: Any) -> None:
@@ -85,59 +71,33 @@ class Select(
 
         Examples:
             Select("id", "name")  # Shorthand for Select().select("id", "name")
-            Select()              # Same as SelectBuilder() - start empty
+            Select()              # Same as Select() - start empty
         """
         super().__init__(**kwargs)
 
-        # Manually initialize dataclass fields here because a custom __init__ is defined.
-        # This is necessary to support the `Select("col1", "col2")` shorthand initialization.
         self._with_parts = {}
         self._expression = None
-        self._schema = None
         self._hints = []
 
         self._create_base_expression()
 
-        # Add columns if provided - just a shorthand for .select()
         if columns:
             self.select(*columns)
 
     @property
-    def _expected_result_type(self) -> "type[SQLResult[RowT]]":
+    def _expected_result_type(self) -> "type[SQLResult]":
         """Get the expected result type for SELECT operations.
 
         Returns:
             type: The SelectResult type.
         """
-        return SQLResult[RowT]
+        return SQLResult
 
     def _create_base_expression(self) -> "exp.Select":
         if self._expression is None or not isinstance(self._expression, exp.Select):
             self._expression = exp.Select()
-        # At this point, self._expression is exp.Select
         return self._expression
 
-    def as_schema(self, schema: "type[RowT]") -> "Select[RowT]":
-        """Return a new Select instance parameterized with the given schema/model type.
-
-        This enables type-safe result mapping: the returned builder will carry the schema type
-        for static analysis and IDE autocompletion. The schema should be a class such as a Pydantic
-        model, dataclass, or msgspec.Struct that describes the expected row shape.
-
-        Args:
-            schema: The schema/model class to use for row typing (e.g., a Pydantic model, dataclass, or msgspec.Struct).
-
-        Returns:
-            Select[RowT]: A new Select instance with RowT set to the provided schema/model type.
-        """
-        new_builder = Select()
-        new_builder._expression = self._expression.copy() if self._expression is not None else None
-        new_builder._parameters = self._parameters.copy()
-        new_builder._parameter_counter = self._parameter_counter
-        new_builder.dialect = self.dialect
-        new_builder._schema = schema  # type: ignore[assignment]
-        return cast("Select[RowT]", new_builder)
-
     def with_hint(
         self,
         hint: "str",
@@ -176,13 +136,11 @@ class Select(
         if isinstance(modified_expr, exp.Select):
             statement_hints = [h["hint"] for h in self._hints if h.get("location") == "statement"]
             if statement_hints:
-                # Parse each hint and create proper hint expressions
                 hint_expressions = []
 
                 def parse_hint(hint: Any) -> exp.Expression:
-                    """Parse a single hint with error handling."""
+                    """Parse a single hint."""
                     try:
-                        # Try to parse hint as an expression (e.g., "INDEX(users idx_name)")
                         hint_str = str(hint)  # Ensure hint is a string
                         hint_expr: Optional[exp.Expression] = exp.maybe_parse(hint_str, dialect=self.dialect_name)
                         if hint_expr:
@@ -197,8 +155,6 @@ class Select(
                     hint_node = exp.Hint(expressions=hint_expressions)
                     modified_expr.set("hint", hint_node)
 
-        # For table-level hints, we'll fall back to comment injection in SQL
-        # since SQLGlot doesn't have a standard way to attach hints to individual tables
         modified_sql = modified_expr.sql(dialect=self.dialect_name, pretty=True)
 
         table_hints = [h for h in self._hints if h.get("location") == "table" and h.get("table")]
@@ -206,7 +162,6 @@ class Select(
             for th in table_hints:
                 table = str(th["table"])
                 hint = th["hint"]
-                # More precise regex that captures the table and optional alias
                 pattern = TABLE_HINT_PATTERN.format(re.escape(table))
                 compiled_pattern = re.compile(pattern, re.IGNORECASE)
 

sqlspec/{statement/builder → builder}/_update.py

@@ -10,27 +10,26 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder._base import QueryBuilder, SafeQuery
-from sqlspec.statement.builder.mixins import (
+from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder.mixins import (
     ReturningClauseMixin,
     UpdateFromClauseMixin,
     UpdateSetClauseMixin,
     UpdateTableClauseMixin,
     WhereClauseMixin,
 )
-from sqlspec.statement.result import SQLResult
-from sqlspec.typing import RowT
+from sqlspec.core.result import SQLResult
+from sqlspec.exceptions import SQLBuilderError
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder._select import Select
+    from sqlspec.builder._select import Select
 
 __all__ = ("Update",)
 
 
 @dataclass(unsafe_hash=True)
 class Update(
-    QueryBuilder[RowT],
+    QueryBuilder,
     WhereClauseMixin,
     ReturningClauseMixin,
     UpdateSetClauseMixin,
@@ -44,7 +43,6 @@ class Update(
 
     Example:
         ```python
-        # Basic UPDATE
         update_query = (
             Update()
             .table("users")
@@ -53,12 +51,10 @@ class Update(
             .where("id = 1")
         )
 
-        # Even more concise with constructor
         update_query = (
             Update("users").set(name="John Doe").where("id = 1")
         )
 
-        # UPDATE with parameterized conditions
         update_query = (
             Update()
             .table("users")
@@ -66,7 +62,6 @@ class Update(
             .where_eq("id", 123)
         )
 
-        # UPDATE with FROM clause (PostgreSQL style)
         update_query = (
             Update()
             .table("users", "u")
@@ -90,9 +85,9 @@ class Update(
             self.table(table)
 
     @property
-    def _expected_result_type(self) -> "type[SQLResult[RowT]]":
+    def _expected_result_type(self) -> "type[SQLResult]":
         """Return the expected result type for this builder."""
-        return SQLResult[RowT]
+        return SQLResult
 
     def _create_base_expression(self) -> exp.Update:
         """Create a base UPDATE expression.
@@ -104,7 +99,7 @@ class Update(
 
     def join(
         self,
-        table: "Union[str, exp.Expression, Select[RowT]]",
+        table: "Union[str, exp.Expression, Select]",
         on: "Union[str, exp.Expression]",
         alias: "Optional[str]" = None,
         join_type: str = "INNER",
@@ -135,10 +130,9 @@ class Update(
             subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=self.dialect))
             table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
 
-            # Merge parameters
-            subquery_params = table._parameters
-            if subquery_params:
-                for p_name, p_value in subquery_params.items():
+            subquery_parameters = table._parameters
+            if subquery_parameters:
+                for p_name, p_value in subquery_parameters.items():
                     self.add_parameter(p_value, name=p_name)
         else:
             table_expr = table

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

@@ -1,14 +1,10 @@
 """SQL statement builder mixins."""
 
-from sqlspec.statement.builder.mixins._cte_and_set_ops import CommonTableExpressionMixin, SetOperationMixin
-from sqlspec.statement.builder.mixins._delete_operations import DeleteFromClauseMixin
-from sqlspec.statement.builder.mixins._insert_operations import (
-    InsertFromSelectMixin,
-    InsertIntoClauseMixin,
-    InsertValuesMixin,
-)
-from sqlspec.statement.builder.mixins._join_operations import JoinClauseMixin
-from sqlspec.statement.builder.mixins._merge_operations import (
+from sqlspec.builder.mixins._cte_and_set_ops import CommonTableExpressionMixin, SetOperationMixin
+from sqlspec.builder.mixins._delete_operations import DeleteFromClauseMixin
+from sqlspec.builder.mixins._insert_operations import InsertFromSelectMixin, InsertIntoClauseMixin, InsertValuesMixin
+from sqlspec.builder.mixins._join_operations import JoinClauseMixin
+from sqlspec.builder.mixins._merge_operations import (
     MergeIntoClauseMixin,
     MergeMatchedClauseMixin,
     MergeNotMatchedBySourceClauseMixin,
@@ -16,19 +12,19 @@ from sqlspec.statement.builder.mixins._merge_operations import (
     MergeOnClauseMixin,
     MergeUsingClauseMixin,
 )
-from sqlspec.statement.builder.mixins._order_limit_operations import (
+from sqlspec.builder.mixins._order_limit_operations import (
     LimitOffsetClauseMixin,
     OrderByClauseMixin,
     ReturningClauseMixin,
 )
-from sqlspec.statement.builder.mixins._pivot_operations import PivotClauseMixin, UnpivotClauseMixin
-from sqlspec.statement.builder.mixins._select_operations import CaseBuilder, SelectClauseMixin
-from sqlspec.statement.builder.mixins._update_operations import (
+from sqlspec.builder.mixins._pivot_operations import PivotClauseMixin, UnpivotClauseMixin
+from sqlspec.builder.mixins._select_operations import CaseBuilder, SelectClauseMixin
+from sqlspec.builder.mixins._update_operations import (
     UpdateFromClauseMixin,
     UpdateSetClauseMixin,
     UpdateTableClauseMixin,
 )
-from sqlspec.statement.builder.mixins._where_clause import HavingClauseMixin, WhereClauseMixin
+from sqlspec.builder.mixins._where_clause import HavingClauseMixin, WhereClauseMixin
 
 __all__ = (
     "CaseBuilder",

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

@@ -36,57 +36,49 @@ class CommonTableExpressionMixin:
             msg = "Cannot add WITH clause: expression not initialized."
             raise SQLBuilderError(msg)
 
-        if not hasattr(self._expression, "with_") and not isinstance(
-            self._expression, (exp.Select, exp.Insert, exp.Update, exp.Delete)
-        ):
+        if not isinstance(self._expression, (exp.Select, exp.Insert, exp.Update, exp.Delete)):
             msg = f"Cannot add WITH clause to {type(self._expression).__name__} expression."
             raise SQLBuilderError(msg)
 
         cte_expr: Optional[exp.Expression] = None
-        if hasattr(query, "to_statement"):
-            # Query is a builder instance
-            built_query = query.to_statement()  # pyright: ignore
-            cte_sql = built_query.to_sql()
-            cte_expr = exp.maybe_parse(cte_sql, dialect=getattr(self, "dialect", None))
-
-            # Merge parameters
-            if hasattr(self, "add_parameter"):
-                parameters = getattr(built_query, "parameters", None) or {}
-                for param_name, param_value in parameters.items():
-                    self.add_parameter(param_value, name=param_name)  # pyright: ignore
-        elif isinstance(query, str):
-            cte_expr = exp.maybe_parse(query, dialect=getattr(self, "dialect", None))
+        if isinstance(query, str):
+            cte_expr = exp.maybe_parse(query, dialect=self.dialect)  # type: ignore[attr-defined]
         elif isinstance(query, exp.Expression):
             cte_expr = query
+        else:
+            built_query = query.to_statement()  # pyright: ignore
+            cte_sql = built_query.sql
+            cte_expr = exp.maybe_parse(cte_sql, dialect=self.dialect)  # type: ignore[attr-defined]
+
+            parameters = built_query.parameters
+            if parameters:
+                if isinstance(parameters, dict):
+                    for param_name, param_value in parameters.items():
+                        self.add_parameter(param_value, name=param_name)  # type: ignore[attr-defined]
+                elif isinstance(parameters, (list, tuple)):
+                    for param_value in parameters:
+                        self.add_parameter(param_value)  # type: ignore[attr-defined]
 
         if not cte_expr:
             msg = f"Could not parse CTE query: {query}"
             raise SQLBuilderError(msg)
 
         if columns:
-            # CTE with explicit column list: name(col1, col2, ...)
             cte_alias_expr = exp.alias_(cte_expr, name, table=[exp.to_identifier(col) for col in columns])
         else:
-            # Simple CTE alias: name
             cte_alias_expr = exp.alias_(cte_expr, name)
 
-        # Different handling for different expression types
-        if hasattr(self._expression, "with_"):
-            existing_with = self._expression.args.get("with")  # pyright: ignore
-            if existing_with:
-                existing_with.expressions.append(cte_alias_expr)
-                if recursive:
-                    existing_with.set("recursive", recursive)
-            else:
-                self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)  # pyright: ignore
-                if recursive:
-                    with_clause = self._expression.find(exp.With)
-                    if with_clause:
-                        with_clause.set("recursive", recursive)
+        existing_with = self._expression.args.get("with")  # pyright: ignore
+        if existing_with:
+            existing_with.expressions.append(cte_alias_expr)
+            if recursive:
+                existing_with.set("recursive", recursive)
         else:
-            # Store CTEs for later application during build
-            if not hasattr(self, "_with_ctes"):
-                setattr(self, "_with_ctes", {})
+            self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)  # type: ignore[union-attr]
+            if recursive:
+                with_clause = self._expression.find(exp.With)
+                if with_clause:
+                    with_clause.set("recursive", recursive)
             self._with_ctes[name] = exp.CTE(this=cte_expr, alias=exp.to_table(name))  # type: ignore[attr-defined]
 
         return self
@@ -96,7 +88,7 @@ class SetOperationMixin:
     """Mixin providing set operations (UNION, INTERSECT, EXCEPT) for SELECT builders."""
 
     _expression: Any = None
-    _parameters: dict[str, Any] = {}
+    _parameters: dict[str, Any]
     dialect: Any = None
 
     def union(self, other: Any, all_: bool = False) -> Self:
@@ -114,25 +106,24 @@ class SetOperationMixin:
         """
         left_query = self.build()  # type: ignore[attr-defined]
         right_query = other.build()
-        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=getattr(self, "dialect", None))
-        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=getattr(self, "dialect", None))
+        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
+        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
         if not left_expr or not right_expr:
             msg = "Could not parse queries for UNION operation"
             raise SQLBuilderError(msg)
         union_expr = exp.union(left_expr, right_expr, distinct=not all_)
         new_builder = type(self)()
-        new_builder.dialect = getattr(self, "dialect", None)
+        new_builder.dialect = self.dialect
         new_builder._expression = union_expr
-        merged_params = dict(left_query.parameters)
+        merged_parameters = dict(left_query.parameters)
         for param_name, param_value in right_query.parameters.items():
-            if param_name in merged_params:
+            if param_name in merged_parameters:
                 counter = 1
                 new_param_name = f"{param_name}_right_{counter}"
-                while new_param_name in merged_params:
+                while new_param_name in merged_parameters:
                     counter += 1
                     new_param_name = f"{param_name}_right_{counter}"
 
-                # Use AST transformation instead of string manipulation
                 def rename_parameter(node: exp.Expression) -> exp.Expression:
                     if isinstance(node, exp.Placeholder) and node.name == param_name:  # noqa: B023
                         return exp.Placeholder(this=new_param_name)  # noqa: B023
@@ -141,10 +132,10 @@ class SetOperationMixin:
                 right_expr = right_expr.transform(rename_parameter)
                 union_expr = exp.union(left_expr, right_expr, distinct=not all_)
                 new_builder._expression = union_expr
-                merged_params[new_param_name] = param_value
+                merged_parameters[new_param_name] = param_value
             else:
-                merged_params[param_name] = param_value
-        new_builder._parameters = merged_params
+                merged_parameters[param_name] = param_value
+        new_builder._parameters = merged_parameters
         return new_builder
 
     def intersect(self, other: Any) -> Self:
@@ -161,19 +152,18 @@ class SetOperationMixin:
         """
         left_query = self.build()  # type: ignore[attr-defined]
         right_query = other.build()
-        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=getattr(self, "dialect", None))
-        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=getattr(self, "dialect", None))
+        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
+        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
         if not left_expr or not right_expr:
             msg = "Could not parse queries for INTERSECT operation"
             raise SQLBuilderError(msg)
         intersect_expr = exp.intersect(left_expr, right_expr, distinct=True)
         new_builder = type(self)()
-        new_builder.dialect = getattr(self, "dialect", None)
+        new_builder.dialect = self.dialect
         new_builder._expression = intersect_expr
-        # Merge parameters
-        merged_params = dict(left_query.parameters)
-        merged_params.update(right_query.parameters)
-        new_builder._parameters = merged_params
+        merged_parameters = dict(left_query.parameters)
+        merged_parameters.update(right_query.parameters)
+        new_builder._parameters = merged_parameters
         return new_builder
 
     def except_(self, other: Any) -> Self:
@@ -190,17 +180,16 @@ class SetOperationMixin:
         """
         left_query = self.build()  # type: ignore[attr-defined]
         right_query = other.build()
-        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=getattr(self, "dialect", None))
-        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=getattr(self, "dialect", None))
+        left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
+        right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
         if not left_expr or not right_expr:
             msg = "Could not parse queries for EXCEPT operation"
             raise SQLBuilderError(msg)
         except_expr = exp.except_(left_expr, right_expr)
         new_builder = type(self)()
-        new_builder.dialect = getattr(self, "dialect", None)
+        new_builder.dialect = self.dialect
         new_builder._expression = except_expr
-        # Merge parameters
-        merged_params = dict(left_query.parameters)
-        merged_params.update(right_query.parameters)
-        new_builder._parameters = merged_params
+        merged_parameters = dict(left_query.parameters)
+        merged_parameters.update(right_query.parameters)
+        new_builder._parameters = merged_parameters
         return new_builder

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

@@ -53,13 +53,14 @@ class InsertValuesMixin:
             raise SQLBuilderError(msg)
         column_exprs = [exp.column(col) if isinstance(col, str) else col for col in columns]
         self._expression.set("columns", column_exprs)
-        # Synchronize the _columns attribute on the builder (if present)
-        if hasattr(self, "_columns"):
-            # If no columns, clear the list
+        try:
+            cols = self._columns  # type: ignore[attr-defined]
             if not columns:
-                self._columns.clear()  # pyright: ignore
+                cols.clear()
             else:
-                self._columns[:] = [col.name if isinstance(col, exp.Column) else str(col) for col in columns]  # pyright: ignore
+                cols[:] = [col.name if isinstance(col, exp.Column) else str(col) for col in columns]
+        except AttributeError:
+            pass
         return self
 
     def values(self, *values: Any) -> Self:
@@ -69,17 +70,29 @@ class InsertValuesMixin:
         if not isinstance(self._expression, exp.Insert):
             msg = "Cannot add values to a non-INSERT expression."
             raise SQLBuilderError(msg)
-        if (
-            hasattr(self, "_columns") and getattr(self, "_columns", []) and len(values) != len(self._columns)  # pyright: ignore
-        ):
-            msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(self._columns)})."  # pyright: ignore
-            raise SQLBuilderError(msg)
+        try:
+            _columns = self._columns  # type: ignore[attr-defined]
+            if _columns and len(values) != len(_columns):
+                msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(_columns)})."
+                raise SQLBuilderError(msg)
+        except AttributeError:
+            pass
         row_exprs = []
-        for v in values:
+        for i, v in enumerate(values):
             if isinstance(v, exp.Expression):
                 row_exprs.append(v)
             else:
-                _, param_name = self.add_parameter(v)  # type: ignore[attr-defined]
+                # Try to use column name if available, otherwise use position-based name
+                try:
+                    _columns = self._columns  # type: ignore[attr-defined]
+                    if _columns and i < len(_columns):
+                        column_name = str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
+                        param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    else:
+                        param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                except AttributeError:
+                    param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                _, param_name = self.add_parameter(v, name=param_name)  # type: ignore[attr-defined]
                 row_exprs.append(exp.var(param_name))
         values_expr = exp.Values(expressions=[row_exprs])
         self._expression.set("expression", values_expr)
@@ -114,7 +127,11 @@ class InsertFromSelectMixin:
         Raises:
             SQLBuilderError: If the table is not set or the select_builder is invalid.
         """
-        if not getattr(self, "_table", None):
+        try:
+            if not self._table:  # type: ignore[attr-defined]
+                msg = "The target table must be set using .into() before adding values."
+                raise SQLBuilderError(msg)
+        except AttributeError:
             msg = "The target table must be set using .into() before adding values."
             raise SQLBuilderError(msg)
         if self._expression is None:
@@ -122,12 +139,11 @@ class InsertFromSelectMixin:
         if not isinstance(self._expression, exp.Insert):
             msg = "Cannot set INSERT source on a non-INSERT expression."
             raise SQLBuilderError(msg)
-        # Merge parameters from the SELECT builder
-        subquery_params = getattr(select_builder, "_parameters", None)
-        if subquery_params:
-            for p_name, p_value in subquery_params.items():
+        subquery_parameters = select_builder._parameters  # pyright: ignore[attr-defined]
+        if subquery_parameters:
+            for p_name, p_value in subquery_parameters.items():
                 self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
-        select_expr = getattr(select_builder, "_expression", None)
+        select_expr = select_builder._expression  # pyright: ignore[attr-defined]
         if select_expr and isinstance(select_expr, exp.Select):
             self._expression.set("expression", select_expr.copy())
         else: