sqlspec 0.71.0__py3-none-any.whl → 0.71.1__py3-none-any.whl

sqlspec/adapters/oracledb/driver.py

@@ -776,7 +776,7 @@ class OracleSyncDriver(OraclePipelineMixin, SyncDriverAdapterBase):
         """Execute query and return results as Apache Arrow format using Oracle native support.
 
         This implementation uses Oracle's native execute_df()/fetch_df_all() methods
-        which return OracleDataFrame objects with Arrow PyCapsule interface, providing
+        which return OracleDataFrame objects with Arrow C Stream interface, providing
         zero-copy data transfer and 5-10x performance improvement over dict conversion.
         If native Arrow is unavailable and native_only is False, it falls back to the
         conversion path.
@@ -1709,7 +1709,7 @@ class OracleAsyncDriver(OraclePipelineMixin, AsyncDriverAdapterBase):
         """Execute query and return results as Apache Arrow format using Oracle native support.
 
         This implementation uses Oracle's native execute_df()/fetch_df_all() methods
-        which return OracleDataFrame objects with Arrow PyCapsule interface, providing
+        which return OracleDataFrame objects with Arrow C Stream interface, providing
         zero-copy data transfer and 5-10x performance improvement over dict conversion.
         If native Arrow is unavailable and native_only is False, it falls back to the
         conversion path.

sqlspec/adapters/pymysql/__init__.py

@@ -6,6 +6,7 @@ from sqlspec.adapters.pymysql.config import (
     PyMysqlConnectionParams,
     PyMysqlDriverFeatures,
     PyMysqlPoolParams,
+    PyMysqlSslParams,
     build_connection_config,
 )
 from sqlspec.adapters.pymysql.core import default_statement_config
@@ -20,6 +21,7 @@ __all__ = (
     "PyMysqlDriverFeatures",
     "PyMysqlExceptionHandler",
     "PyMysqlPoolParams",
+    "PyMysqlSslParams",
     "build_connection_config",
     "default_statement_config",
 )

sqlspec/builder/_base.py

@@ -28,7 +28,7 @@ from sqlglot.schema import MappingSchema
 
 from sqlspec.builder._locking import register_lock_generator
 from sqlspec.builder._parsing_utils import _normalize_dialect, _resolve_dialect
-from sqlspec.builder._vector_distance import has_vector_distance_ancestor
+from sqlspec.builder._vector_distance import has_vector_distance_ancestor, register_vector_distance_generator
 from sqlspec.core import (
     SQL,
     ParameterStyle,
@@ -46,13 +46,21 @@ from sqlspec.utils.logging import get_logger
 from sqlspec.utils.type_guards import has_expression_and_parameters, is_expression
 from sqlspec.utils.uuids import uuid4
 
-__all__ = ("BuiltQuery", "ExpressionBuilder", "QueryBuilder")
+__all__ = (
+    "SUBQUERY_PARAMETERS_META_KEY",
+    "BuiltQuery",
+    "ExpressionBuilder",
+    "QueryBuilder",
+    "register_subquery_fragment",
+)
 
 MAX_PARAMETER_COLLISION_ATTEMPTS = 1000
 PARAMETER_INDEX_PATTERN = re.compile(r"^param_(?P<index>\d+)$")
 _PARAMETER_SUFFIX_PATTERN = re.compile(r"^(?P<base>.+)_(?P<index>\d+)$")
 _UPPER_FOLDING_DIALECTS: Final[frozenset[str]] = frozenset({"oracle", "db2"})
 _UNQUOTED_IDENTIFIER_PATTERN = re.compile(r"^[A-Za-z_][\w$#]*$")
+SUBQUERY_PARAMETERS_META_KEY: Final[str] = "sqlspec_subquery_parameters"
+_SUBQUERY_FRAGMENTS_ISSUED = False
 
 
 logger = get_logger(__name__)
@@ -350,6 +358,7 @@ class QueryBuilder:
                 identify = self._should_identify(target_dialect)
                 if normalized_expression.find(exp.Lock) and target_dialect != "db2":
                     register_lock_generator(target_dialect)
+                register_vector_distance_generator(target_dialect)
                 sql_string = normalized_expression.sql(
                     dialect=target_dialect, pretty=True, identify=identify, copy=False
                 )
@@ -367,7 +376,9 @@ class QueryBuilder:
 
         Args:
             show_parameters: If True, replace parameter placeholders with actual values (for debugging).
-                If False (default), return SQL with parameter placeholders.
+                If False (default), return SQL with parameter placeholders. Every named
+                placeholder style the builder renders is substituted (``:name``, ``%(name)s``,
+                ``@name``, and ``$name``).
             dialect: Optional dialect override. If provided, generates SQL for this dialect
                 instead of the builder's default dialect.
 
@@ -389,10 +400,11 @@ class QueryBuilder:
             return sql
 
         sorted_names = sorted(parameters, key=len, reverse=True)
-        pattern = re.compile(r":(" + "|".join(re.escape(name) for name in sorted_names) + r")\b")
+        names_pattern = "|".join(re.escape(name) for name in sorted_names)
+        pattern = re.compile(rf"%\(({names_pattern})\)s|(?<![:\w])[:@$]({names_pattern})\b")
 
         def _replace_match(match: "re.Match[str]") -> str:
-            param_name = match.group(1)
+            param_name = match.group(1) or match.group(2)
             param_value = parameters[param_name]
             if isinstance(param_value, str):
                 escaped = param_value.replace("'", "''")
@@ -534,6 +546,7 @@ class QueryBuilder:
         identify = self._should_identify(target_dialect)
         if expr.find(exp.Lock) and target_dialect != "db2":
             register_lock_generator(target_dialect)
+        register_vector_distance_generator(target_dialect)
         sql_string = expr.sql(dialect=target_dialect, pretty=True, identify=identify, copy=not copy)
         sql_string = self._postprocess_built_sql(sql_string, dialect=dialect)
         return BuiltQuery(
@@ -838,6 +851,49 @@ class QueryBuilder:
         else:
             self._parameter_name_counters.setdefault(name, 0)
 
+    def _merge_subquery_fragments(self, expression: exp.Expr) -> exp.Expr:
+        """Merge parameters carried by ``sql.exists_`` / ``sql.in_`` / ``sql.any_`` / ``sql.all_`` fragments.
+
+        Fragments built from parameterized subquery builders carry their parameters in
+        ``SUBQUERY_PARAMETERS_META_KEY`` metadata. The expression is copied before
+        placeholders are renamed, so one fragment can be reused across builders. The
+        tree is only scanned once any fragment has been created in the process.
+
+        Args:
+            expression: Condition expression about to be attached to this builder.
+
+        Returns:
+            The expression with fragment parameters merged into this builder.
+        """
+        if not _SUBQUERY_FRAGMENTS_ISSUED:
+            return expression
+        has_carriers = False
+        for node in expression.walk():
+            if isinstance(node, exp.In) and isinstance(node.this, exp.Var) and not node.this.name:
+                self._raise_builder_error(
+                    "sql.in_() returns an IN fragment without a left operand; use .where_in(column, subquery) instead."
+                )
+            if node.meta_get(SUBQUERY_PARAMETERS_META_KEY) is not None:
+                has_carriers = True
+        if not has_carriers:
+            return expression
+
+        merged = expression.copy()
+        for node in list(merged.walk()):
+            parameters = node.meta_get(SUBQUERY_PARAMETERS_META_KEY)
+            if parameters is None:
+                continue
+            del node.meta[SUBQUERY_PARAMETERS_META_KEY]
+            param_mapping: dict[str, str] = {}
+            for name, value in parameters.items():
+                target_name = self._next_parameter_name(name) if name in self._parameters else name
+                _, actual_name = self.add_parameter(value, name=target_name)
+                if actual_name != name:
+                    param_mapping[name] = actual_name
+            if param_mapping:
+                self._update_placeholders(node, param_mapping)
+        return merged
+
     def _next_parameter_name(self, base_name: str) -> str:
         """Generate unique parameter name when collision occurs.
 
@@ -1192,6 +1248,7 @@ class QueryBuilder:
 
         if statement_expression.find(exp.Lock) and resolved_dialect != "db2":
             register_lock_generator(resolved_dialect)
+        register_vector_distance_generator(resolved_dialect)
         if self._folds_unquoted_to_upper(resolved_dialect):
             statement_expression = self._unquote_identifiers(statement_expression)
         return _BuilderCacheEntry(statement_expression, resolved_dialect)
@@ -1415,3 +1472,20 @@ def _unquote_identifier(node: exp.Expr) -> exp.Expr:
     ):
         node.set("quoted", False)
     return node
+
+
+def register_subquery_fragment(expression: exp.Expr, parameters: "Mapping[str, Any]") -> exp.Expr:
+    """Mark a subquery fragment and attach its bound parameters for later merging.
+
+    Args:
+        expression: The ``EXISTS`` / ``IN`` / ``ANY`` / ``ALL`` fragment.
+        parameters: Parameters bound by the fragment's subquery builder.
+
+    Returns:
+        The same expression, carrying ``parameters`` in its metadata when any exist.
+    """
+    global _SUBQUERY_FRAGMENTS_ISSUED
+    _SUBQUERY_FRAGMENTS_ISSUED = True
+    if parameters:
+        expression.meta[SUBQUERY_PARAMETERS_META_KEY] = dict(parameters)
+    return expression

sqlspec/builder/_column.py

@@ -25,10 +25,19 @@ class ColumnExpression:
         self._expression = expression
 
     def __and__(self, other: "ColumnExpression") -> "ColumnExpression":
-        """Combine with AND operator (&)."""
+        """Combine with AND operator (&).
+
+        ``OR`` operands are wrapped in parentheses because ``AND`` binds tighter
+        than ``OR`` in SQL, so ``a & (b | c)`` must not render as ``a AND b OR c``.
+        """
         if not isinstance(other, ColumnExpression):
             return NotImplemented
-        return ColumnExpression(exp.And(this=self._expression.copy(), expression=other._expression.copy()))
+        return ColumnExpression(
+            exp.And(
+                this=_wrap_operand(self._expression.copy(), exp.Or),
+                expression=_wrap_operand(other._expression.copy(), exp.Or),
+            )
+        )
 
     def __or__(self, other: "ColumnExpression") -> "ColumnExpression":
         """Combine with OR operator (|)."""
@@ -37,8 +46,12 @@ class ColumnExpression:
         return ColumnExpression(exp.Or(this=self._expression.copy(), expression=other._expression.copy()))
 
     def __invert__(self) -> "ColumnExpression":
-        """Apply NOT operator (~)."""
-        return ColumnExpression(exp.Not(this=self._expression.copy()))
+        """Apply NOT operator (~).
+
+        ``AND`` / ``OR`` operands are wrapped in parentheses because ``NOT`` binds
+        tighter than both connectors, so ``~(a & b)`` must render as ``NOT (a AND b)``.
+        """
+        return ColumnExpression(exp.Not(this=_wrap_operand(self._expression.copy(), exp.Connector)))
 
     def __bool__(self) -> bool:
         """Prevent accidental use of 'and'/'or' keywords."""
@@ -165,13 +178,12 @@ class _ScalarExpressionMixin:
         )
 
     def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
-        """SQL <> ANY(...) clause."""
-        converted_values = [self._convert_value(v) for v in values]
-        return ColumnExpression(
-            exp.NEQ(
-                this=self._expression, expression=exp.Any(this=exp.Paren(this=exp.Array(expressions=converted_values)))
-            )
-        )
+        """SQL NOT (column = ANY(...)) clause.
+
+        ``column <> ANY(...)`` is true when any element differs, so the negation
+        wraps the ``= ANY`` comparison, matching ``NotAnyCollectionFilter``.
+        """
+        return ColumnExpression(exp.Not(this=self.any_(values)._expression))
 
     def cast(self, data_type: str) -> "FunctionColumn":
         """SQL CAST() function."""
@@ -388,6 +400,21 @@ class FunctionColumn(_ScalarExpressionMixin):
         return hash(id(self._expression))
 
 
+def _wrap_operand(expression: exp.Expr, lower_precedence: type[exp.Expr]) -> exp.Expr:
+    """Parenthesize an operand whose operator binds looser than its new parent.
+
+    Args:
+        expression: The operand expression.
+        lower_precedence: Expression type that needs parentheses under the parent operator.
+
+    Returns:
+        The operand, wrapped in ``exp.Paren`` when required.
+    """
+    if isinstance(expression, lower_precedence):
+        return exp.Paren(this=expression)
+    return expression
+
+
 def _convert_value(value: Any) -> exp.Expr:
     """Convert a Python value to a SQLGlot expression.
 

sqlspec/builder/_factory.py

@@ -13,7 +13,8 @@ from sqlglot.dialects.dialect import DialectType
 from sqlglot.errors import ParseError as SQLGlotParseError
 
 from sqlspec.builder._base import QueryBuilder
-from sqlspec.builder._column import Column
+from sqlspec.builder._column import Column, ColumnExpression, FunctionColumn
+from sqlspec.builder._column import _convert_value as convert_column_value
 from sqlspec.builder._ddl import (
     AlterTable,
     CommentOn,
@@ -55,6 +56,7 @@ from sqlspec.builder._parsing_utils import (
     _resolve_dialect,
     _rollup_expression,
     extract_expression,
+    parse_column_expression,
     to_expression,
 )
 from sqlspec.builder._select import Case, Select, SubqueryBuilder, WindowFunctionBuilder
@@ -77,7 +79,9 @@ __all__ = ("SQLFactory", "build_copy_from_statement", "build_copy_statement", "b
 logger = get_logger("sqlspec.builder.factory")
 
 BuilderT = TypeVar("BuilderT", bound=QueryBuilder)
-ColumnLike: TypeAlias = Union[str, exp.Expr, "ExpressionWrapper", "Case", "Column"]
+ColumnLike: TypeAlias = Union[
+    str, exp.Expr, "ExpressionWrapper", "Case", "Column", "FunctionColumn", "ColumnExpression"
+]
 
 MIN_SQL_LIKE_STRING_LENGTH = 6
 MIN_DECODE_ARGS = 2
@@ -358,7 +362,11 @@ class SQLFactory:
         return create_join_builder("cross join", lateral=True)
 
     def select(
-        self, *columns_or_sql: Union[str, exp.Expr, Column, "SQL", "Case"], dialect: DialectType = None
+        self,
+        *columns_or_sql: Union[
+            str, exp.Expr, Column, FunctionColumn, ColumnExpression, "ExpressionWrapper", "SQL", "Case"
+        ],
+        dialect: DialectType = None,
     ) -> "Select":
         builder_dialect = _resolve_dialect(dialect, self.dialect)
         if len(columns_or_sql) == 1 and isinstance(columns_or_sql[0], str):
@@ -1101,16 +1109,35 @@ class SQLFactory:
         return FunctionExpression(exp.Any(this=values))
 
     @staticmethod
-    def not_any_(values: list[Any] | exp.Expr | str) -> FunctionExpression:
-        """Create a NOT ANY expression for use with comparison operators.
+    def not_any_(column: "str | Column | exp.Expr", values: Any) -> ColumnExpression:
+        """Create a ``NOT (column = ANY(...))`` condition.
 
-        Args:
-            values: Values, expression, or subquery for the NOT ANY clause.
+        ``column <> ANY(...)`` is true whenever any element differs, so the negation
+        wraps the ``= ANY`` comparison. The result matches ``Column.not_any_`` and
+        ``NotAnyCollectionFilter`` and renders as ``column <> ALL (...)`` on optimizing
+        dialects such as PostgreSQL.
 
-        Returns:
-            NOT ANY expression.
-        """
-        return FunctionExpression(exp.Not(this=SQLFactory.any(values).expression))
+        Args:
+            column: Column name (``"status"`` or ``"t.status"``), ``Column``, or expression.
+            values: Iterable of values bound as parameters, or a subquery given as a
+                query builder, sqlglot expression, or SQL string. Parameters bound by a
+                subquery builder are merged into the outer query. Subqueries stay
+                parenthesized so the optimizer keeps ``<> ALL (subquery)`` instead of
+                rewriting it into an anti-join, which would change the result when the
+                subquery returns ``NULL``.
+
+        Returns:
+            Condition usable with ``.where()``, ``.having()``, ``&``, ``|``, and ``~``.
+        """
+        left = column.sqlglot_expression if isinstance(column, Column) else parse_column_expression(column)
+        any_expression: exp.Expr
+        if isinstance(values, (list, tuple, set, frozenset)):
+            converted = [convert_column_value(value) for value in values]
+            any_expression = exp.Any(this=exp.Paren(this=exp.Array(expressions=converted)))
+        else:
+            any_expression = SubqueryBuilder("any")(values)
+            any_expression.set("this", exp.paren(any_expression.this, copy=False))
+        return ColumnExpression(exp.Not(this=exp.EQ(this=left, expression=any_expression)))
 
     @staticmethod
     def concat(*expressions: str | exp.Expr) -> StringExpression:
@@ -1325,19 +1352,25 @@ class SQLFactory:
         Args:
             table_name: Name of the table to insert into
             column_count: Number of columns (for placeholder generation)
-            placeholder_style: Placeholder style ("?" for SQLite/PostgreSQL, "%s" for MySQL, ":1" for Oracle)
+            placeholder_style: Positional placeholder style: ``"?"`` (qmark), ``"%s"`` (format),
+                ``":1"`` (Oracle numeric), or ``"$1"`` (PostgreSQL numeric). Numeric styles
+                number the placeholders from 1.
 
         Returns:
             INSERT expression with placeholders for bulk operations
         """
+        placeholders: list[exp.Expr]
+        if placeholder_style == "?":
+            placeholders = [exp.Placeholder() for _ in range(column_count)]
+        elif placeholder_style[:1] in {":", "$"} and placeholder_style[1:].isdigit():
+            prefix = placeholder_style[0]
+            placeholders = [exp.Var(this=f"{prefix}{index}") for index in range(1, column_count + 1)]
+        else:
+            placeholders = [exp.Var(this=placeholder_style) for _ in range(column_count)]
         return FunctionExpression(
             exp.Insert(
                 this=exp.Table(this=exp.to_identifier(table_name)),
-                expression=exp.Values(
-                    expressions=[
-                        exp.Tuple(expressions=[exp.Placeholder(this=placeholder_style) for _ in range(column_count)])
-                    ]
-                ),
+                expression=exp.Values(expressions=[exp.Tuple(expressions=placeholders)]),
             )
         )
 

sqlspec/builder/_generation.py

@@ -2,10 +2,38 @@
 
 from typing import TYPE_CHECKING, cast
 
+from sqlglot import Dialect
+from sqlglot.generator import Generator
+
 if TYPE_CHECKING:
-    from sqlglot.generator import Generator
+    from sqlglot.dialects.dialect import DialectType
+
+__all__ = ("generator_class_for_dialect", "invalidate_generator_dispatch")
+
+
+def generator_class_for_dialect(dialect: "DialectType | str | None") -> "type[Generator]":
+    """Resolve the SQLGlot generator class that renders a dialect.
 
-__all__ = ("invalidate_generator_dispatch",)
+    Args:
+        dialect: Dialect name, class, or instance; ``None`` selects the base generator.
+
+    Returns:
+        The dialect's generator class.
+    """
+    if dialect is None:
+        return Generator
+
+    dialect_class: type[Dialect]
+    if isinstance(dialect, str):
+        dialect_class = type(Dialect.get_or_raise(dialect))
+    elif isinstance(dialect, type) and issubclass(dialect, Dialect):
+        dialect_class = dialect
+    elif isinstance(dialect, Dialect):
+        dialect_class = type(dialect)
+    else:
+        dialect_class = type(Dialect.get_or_raise(str(dialect)))
+
+    return dialect_class.generator_class
 
 
 def invalidate_generator_dispatch(*generator_classes: "type[object]") -> None:

sqlspec/builder/_join.py

@@ -350,19 +350,54 @@ def _join_for_type(table_expr: exp.Expr, on_expr: exp.Expr | None, join_type: st
 
 
 def _apply_lateral_modifier(join_expr: exp.Join) -> None:
-    current_kind = join_expr.args.get("kind")
-    current_side = join_expr.args.get("side")
-
-    if current_kind == "CROSS":
-        join_expr.set("kind", "CROSS LATERAL")
-    elif current_kind == "OUTER" and current_side == "FULL":
-        join_expr.set("side", "FULL")
-        join_expr.set("kind", "OUTER LATERAL")
-    elif current_side:
-        join_expr.set("kind", f"{current_side} LATERAL")
-        join_expr.set("side", None)
+    """Turn a join into a LATERAL join.
+
+    The join target is wrapped in ``exp.Lateral`` so sqlglot renders the standard
+    ``JOIN LATERAL`` / ``LEFT JOIN LATERAL`` / ``CROSS JOIN LATERAL`` form accepted by
+    PostgreSQL, MySQL, DuckDB, and Snowflake. Non-cross lateral joins without a
+    condition get ``ON TRUE`` because PostgreSQL requires a join qualifier for them.
+    """
+    join_expr.set("this", _lateral_source(join_expr.this))
+    if join_expr.args.get("kind") != "CROSS" and join_expr.args.get("on") is None:
+        join_expr.set("on", exp.true())
+
+
+def _lateral_source(table_expr: exp.Expr) -> exp.Expr:
+    """Wrap a join target in ``exp.Lateral``, moving its alias onto the LATERAL node.
+
+    Args:
+        table_expr: Parsed join target (aliased subquery, table function, or table).
+
+    Returns:
+        The ``exp.Lateral`` join target.
+    """
+    if isinstance(table_expr, exp.Lateral):
+        return table_expr
+
+    source = table_expr
+    alias_node: exp.Expr | None = None
+    if isinstance(source, exp.Alias):
+        alias_node = exp.TableAlias(this=exp.to_identifier(source.alias))
+        source = source.this
     else:
-        join_expr.set("kind", "LATERAL")
+        raw_alias = source.args.get("alias")
+        if raw_alias is not None:
+            source = source.copy()
+            source.set("alias", None)
+            if isinstance(raw_alias, exp.TableAlias):
+                alias_node = raw_alias.copy()
+            else:
+                alias_identifier = (
+                    raw_alias.copy() if isinstance(raw_alias, exp.Identifier) else exp.to_identifier(str(raw_alias))
+                )
+                alias_node = exp.TableAlias(this=alias_identifier)
+
+    if isinstance(source, exp.Paren) and isinstance(source.this, exp.Query):
+        source = exp.Subquery(this=source.this)
+    elif isinstance(source, exp.Table) and isinstance(source.this, exp.Func):
+        source = source.this
+
+    return exp.Lateral(this=source, alias=alias_node)
 
 
 def _attach_as_of_version(
@@ -377,9 +412,9 @@ def _attach_as_of_version(
         target_alias = inner_table.alias
         inner_table = inner_table.this
     elif isinstance(inner_table, exp.Table):
-        alias_expr = inner_table.args.get("alias")
-        if alias_expr is not None:
-            target_alias = alias_expr.this
+        table_alias = inner_table.alias
+        if table_alias:
+            target_alias = table_alias
             inner_table.set("alias", None)
 
     version = exp.Version(this=as_of_type or "TIMESTAMP", kind="AS OF", expression=exp.convert(as_of))

sqlspec/builder/_locking.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, ClassVar, Protocol, cast
 from sqlglot import Dialect, exp
 from sqlglot.generator import Generator
 
-from sqlspec.builder._generation import invalidate_generator_dispatch
+from sqlspec.builder._generation import generator_class_for_dialect, invalidate_generator_dispatch
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -20,16 +20,12 @@ class _GeneratorClass(Protocol):
     TRANSFORMS: ClassVar[MutableMapping[type[exp.Lock], Callable[[Generator, exp.Lock], str]]]
 
 
-class _DialectClass(Protocol):
-    Generator: ClassVar[type[_GeneratorClass]]
-
-
 _REGISTERED_LOCK_GENERATORS: set[type[_GeneratorClass]] = set()
 
 
 def register_lock_generator(dialect: "DialectType | str | None") -> None:
     """Register lock-clause rendering for the dialect being rendered."""
-    generator_class = _generator_class_for_dialect(dialect)
+    generator_class = cast("type[_GeneratorClass]", generator_class_for_dialect(dialect))
     if generator_class in _REGISTERED_LOCK_GENERATORS:
         return
 
@@ -50,7 +46,14 @@ def _render_lock_targets(generator: "Generator", expressions: "Iterable[exp.Expr
 
 
 def _lock_sql(generator: "Generator", expression: exp.Lock) -> str:
-    if not generator.LOCKING_READS_SUPPORTED and type(generator.dialect).__name__ != "Spanner":
+    """Render a lock clause.
+
+    The dialect-neutral base generator keeps lock clauses so builds without a
+    dialect preserve ``FOR UPDATE`` / ``FOR SHARE``; dialects that cannot express
+    locking reads still drop them.
+    """
+    dialect_class = type(generator.dialect)
+    if not generator.LOCKING_READS_SUPPORTED and dialect_class is not Dialect and dialect_class.__name__ != "Spanner":
         generator.unsupported("Locking reads using 'FOR UPDATE/SHARE' are not supported")
         return ""
 
@@ -72,20 +75,3 @@ def _lock_sql(generator: "Generator", expression: exp.Lock) -> str:
             wait = " NOWAIT" if wait else " SKIP LOCKED"
 
     return f"{lock_type}{target_sql}{wait or ''}"
-
-
-def _generator_class_for_dialect(dialect: "DialectType | str | None") -> "type[_GeneratorClass]":
-    if dialect is None:
-        return cast("type[_GeneratorClass]", Generator)
-
-    dialect_class: type[Dialect]
-    if isinstance(dialect, str):
-        dialect_class = type(Dialect.get_or_raise(dialect))
-    elif isinstance(dialect, type) and issubclass(dialect, Dialect):
-        dialect_class = dialect
-    elif isinstance(dialect, Dialect):
-        dialect_class = type(dialect)
-    else:
-        dialect_class = type(Dialect.get_or_raise(str(dialect)))
-
-    return cast("_DialectClass", dialect_class).Generator

sqlspec/builder/_parsing_utils.py

@@ -80,6 +80,7 @@ _BARE_KEYWORDS: Final[frozenset[str]] = frozenset({
     "where",
 })
 _PARAMETER_VALIDATOR = ParameterValidator()
+_NON_IDENTIFIER_PATTERN: Final["re.Pattern[str]"] = re.compile(r"\W+")
 _DIALECT_ALIASES: Final[dict[str, str]] = {
     "ase": "sybase",
     "cockroach": "postgres",
@@ -94,6 +95,9 @@ _DIALECT_ALIASES: Final[dict[str, str]] = {
 def extract_column_name(column: str | exp.Column) -> str:
     """Extract column name from column expression for parameter naming.
 
+    Non-column expressions such as ``COUNT(*)`` or ``SUM(o.amount)`` become
+    identifier-safe names (``count``, ``sum_o_amount``) so placeholders stay valid.
+
     Args:
         column: Column expression (string or SQLGlot Column)
 
@@ -104,7 +108,7 @@ def extract_column_name(column: str | exp.Column) -> str:
         col_expr: exp.Expr | None = exp.maybe_parse(column)
         if isinstance(col_expr, exp.Column):
             return col_expr.name
-        return column.split(".")[-1] if "." in column else column
+        return _NON_IDENTIFIER_PATTERN.sub("_", column).strip("_").lower() or "column"
     if isinstance(column, exp.Column):
         return column.name
     return "column"