sqlspec 0.50.0__tar.gz → 0.50.1__tar.gz

{sqlspec-0.50.0 → sqlspec-0.50.1}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.15.17"
+    rev: "v0.15.18"
     hooks:
       - id: ruff
         args: ["--fix"]

{sqlspec-0.50.0 → sqlspec-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.50.0
+Version: 0.50.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.50.0 → sqlspec-0.50.1}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.50.0"
+version = "0.50.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -201,6 +201,7 @@ packages = []
 
 
 
+
 [tool.hatch.build.targets.wheel.hooks.mypyc]
 dependencies = ["hatch-mypyc", "hatch-cython", "mypy>=2.0.0"]
 enable-by-default = false
@@ -302,7 +303,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.50.0"
+current_version = "0.50.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/adapters/duckdb/config.py

@@ -112,6 +112,12 @@ class DuckDBExtensionConfig(TypedDict):
     force_install: NotRequired[bool]
     """Force reinstallation of the extension."""
 
+    install: NotRequired[bool]
+    """Force an explicit install_extension() call even for a name-only config."""
+
+    required: NotRequired[bool]
+    """When True, install/load failure raises instead of best-effort WARNING."""
+
 
 class DuckDBSecretConfig(TypedDict):
     """DuckDB secret configuration for AI/API integrations."""
@@ -134,6 +140,9 @@ class DuckDBSecretConfig(TypedDict):
     persistent: NotRequired[bool]
     """Persist the secret to DuckDB's configured secret directory."""
 
+    required: NotRequired[bool]
+    """When True, secret-creation failure raises (and is verified). Default best-effort."""
+
 
 class DuckDBDriverFeatures(TypedDict):
     """TypedDict for DuckDB driver features configuration.

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/adapters/duckdb/pool.py

@@ -21,6 +21,7 @@ __all__ = ("DuckDBConnectionPool",)
 
 
 _SQL_IDENTIFIER_RE: Final[re.Pattern[str]] = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$")
+_EXPLICIT_INSTALL_KEYS: Final[tuple[str, ...]] = ("version", "repository", "repository_url")
 
 
 logger = get_logger(POOL_LOGGER_NAME)
@@ -50,6 +51,7 @@ class DuckDBConnectionPool:
         "_extension_flags",
         "_extensions",
         "_health_check_interval",
+        "_installed_signatures",
         "_is_memory_db",
         "_lock",
         "_on_connection_create",
@@ -87,6 +89,7 @@ class DuckDBConnectionPool:
         self._extension_flags = extension_flags or {}
         self._secrets = secrets or []
         self._on_connection_create = on_connection_create
+        self._installed_signatures: set[tuple[Any, ...]] = set()
         self._thread_local = threading.local()
         self._lock = threading.RLock()
         self._pool_id = str(uuid.uuid4())[:8]
@@ -128,21 +131,29 @@ class DuckDBConnectionPool:
             if not ext_name:
                 continue
 
-            install_kwargs = {}
-            if "version" in ext_config:
-                install_kwargs["version"] = ext_config["version"]
-            if "repository" in ext_config:
-                install_kwargs["repository"] = ext_config["repository"]
-            if "repository_url" in ext_config:
-                install_kwargs["repository_url"] = ext_config["repository_url"]
-            if ext_config.get("force_install", False):
-                install_kwargs["force_install"] = True
-
-            if install_kwargs:
-                connection.install_extension(ext_name, **install_kwargs)
-            else:
-                connection.install_extension(ext_name)
-            connection.load_extension(ext_name)
+            required = bool(ext_config.get("required", False))
+            install_kwargs: dict[str, Any] = {k: ext_config[k] for k in _EXPLICIT_INSTALL_KEYS if k in ext_config}
+            force_install = bool(ext_config.get("force_install", False))
+            explicit_install = bool(ext_config.get("install", False)) or force_install or bool(install_kwargs)
+
+            if explicit_install:
+                self._install_extension_once(connection, ext_name, install_kwargs, force_install, required)
+
+            try:
+                connection.load_extension(ext_name)
+            except Exception as exc:
+                if required:
+                    raise
+                log_with_context(
+                    logger,
+                    logging.WARNING,
+                    "pool.extension.load.failed",
+                    adapter=_ADAPTER_NAME,
+                    pool_id=self._pool_id,
+                    database=self._database_name,
+                    extension=ext_name,
+                    error=str(exc),
+                )
 
         for secret_config in self._secrets:
             _create_secret(connection, secret_config)
@@ -154,6 +165,47 @@ class DuckDBConnectionPool:
 
         return connection
 
+    def _install_extension_once(
+        self,
+        connection: "DuckDBConnection",
+        ext_name: str,
+        install_kwargs: "dict[str, Any]",
+        force_install: bool,
+        required: bool,
+    ) -> None:
+        """Install an extension once per pool per signature, best-effort unless required."""
+        signature = (
+            ext_name,
+            install_kwargs.get("version"),
+            install_kwargs.get("repository"),
+            install_kwargs.get("repository_url"),
+        )
+        with self._lock:
+            if not force_install and signature in self._installed_signatures:
+                return
+            try:
+                if force_install:
+                    connection.install_extension(ext_name, force_install=True, **install_kwargs)
+                elif install_kwargs:
+                    connection.install_extension(ext_name, **install_kwargs)
+                else:
+                    connection.install_extension(ext_name)
+            except Exception as exc:
+                if required:
+                    raise
+                log_with_context(
+                    logger,
+                    logging.WARNING,
+                    "pool.extension.install.failed",
+                    adapter=_ADAPTER_NAME,
+                    pool_id=self._pool_id,
+                    database=self._database_name,
+                    extension=ext_name,
+                    error=str(exc),
+                )
+                return
+            self._installed_signatures.add(signature)
+
     def _apply_extension_flags(self, connection: DuckDBConnection) -> None:
         """Apply connection-level extension flags via SET statements."""
 
@@ -335,12 +387,18 @@ def _create_secret(connection: DuckDBConnection, secret_config: dict[str, Any])
     if not (secret_name and secret_type):
         return
 
-    _validate_sql_identifier(secret_name, "secret_name")
-    _validate_sql_identifier(secret_type, "secret_type")
-
-    sql = _build_secret_sql(secret_config, secret_name, secret_type)
-    connection.execute(sql)
-    _verify_secret(connection, secret_config, secret_name, secret_type)
+    required = bool(secret_config.get("required", False))
+    try:
+        _validate_sql_identifier(secret_name, "secret_name")
+        _validate_sql_identifier(secret_type, "secret_type")
+        sql = _build_secret_sql(secret_config, secret_name, secret_type)
+        connection.execute(sql)
+        if required:
+            _verify_secret(connection, secret_config, secret_name, secret_type)
+    except Exception:
+        if required:
+            raise
+        logger.warning("DuckDB secret %r creation failed (best-effort)", secret_name)
 
 
 def _build_secret_sql(secret_config: dict[str, Any], secret_name: str, secret_type: str) -> str:

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/__init__.py

@@ -176,6 +176,3 @@ __all__ = (
     "sql",
     "to_expression",
 )
-
-# Register temporal query SQL generators on module import
-register_version_generators()

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_explain.py

@@ -7,6 +7,7 @@ dialect-aware SQL generation.
 from typing import TYPE_CHECKING, Any
 
 from mypy_extensions import trait
+from sqlglot import Dialect
 from typing_extensions import Self
 
 from sqlspec.core import SQL, StatementConfig
@@ -58,7 +59,9 @@ def normalize_dialect_name(dialect: "DialectType | None") -> str | None:
         return None
     if isinstance(dialect, str):
         return dialect.lower()
-    return dialect.__class__.__name__.lower()
+    if isinstance(dialect, type) and issubclass(dialect, Dialect):
+        return dialect.__name__.lower()
+    return type(dialect).__name__.lower()
 
 
 def build_postgres_explain(statement_sql: str, options: "ExplainOptions") -> str:

sqlspec-0.50.1/sqlspec/builder/_generation.py

@@ -0,0 +1,27 @@
+"""SQLGlot generator registration helpers."""
+
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from sqlglot.generator import Generator
+
+__all__ = ("invalidate_generator_dispatch",)
+
+
+def invalidate_generator_dispatch(*generator_classes: "type[object]") -> None:
+    """Clear SQLGlot generator dispatch entries after transform registration.
+
+    SQLGlot caches generator dispatch lookups. SQLSpec mutates ``TRANSFORMS``
+    on existing generator classes for compiled sqlglot compatibility, so those
+    cache entries need to be invalidated after registration.
+
+    Args:
+        *generator_classes: SQLGlot generator classes whose dispatch caches should be cleared.
+    """
+    try:
+        from sqlglot.generator import _DISPATCH_CACHE  # pyright: ignore[reportPrivateUsage,reportPrivateImportUsage]
+    except ImportError:
+        return
+
+    for generator_class in generator_classes:
+        _DISPATCH_CACHE.pop(cast("type[Generator]", generator_class), None)

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_join.py

@@ -12,6 +12,7 @@ from typing_extensions import Self
 
 from sqlspec.builder._base import BuiltQuery, QueryBuilder
 from sqlspec.builder._parsing_utils import parse_table_expression
+from sqlspec.builder._temporal import register_version_generators
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_expression_and_parameters, has_expression_and_sql, has_parameter_builder
 
@@ -114,6 +115,8 @@ def _apply_lateral_modifier(join_expr: exp.Join) -> None:
 def _attach_as_of_version(
     table_expr: exp.Expr, alias: str | None, as_of: Any, as_of_type: str | None = None
 ) -> exp.Expr:
+    register_version_generators()
+
     inner_table = table_expr.copy()
     target_alias = alias
 

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_merge.py

@@ -11,7 +11,6 @@ from decimal import Decimal
 from itertools import starmap
 from typing import TYPE_CHECKING, Any, cast
 
-import sqlglot as sg
 from mypy_extensions import trait
 from sqlglot import exp
 from sqlglot.errors import ParseError
@@ -237,14 +236,32 @@ class MergeUsingClauseMixin(_MergeAssignmentMixin):
         alias_name = alias or "src"
         recordset_alias = f"{alias_name}_data"
 
-        column_type_spec = ", ".join([f"{col} {self._infer_postgres_type(sample_values.get(col))}" for col in columns])
-        column_selects = ", ".join(columns)
-        from_sql = (
-            f"SELECT {column_selects} FROM jsonb_to_recordset(:{json_param_name}::jsonb) AS "
-            f"{recordset_alias}({column_type_spec})"
+        recordset_table = exp.Table(
+            this=exp.Anonymous(
+                this="jsonb_to_recordset",
+                expressions=[
+                    exp.Cast(
+                        this=exp.Placeholder(this=json_param_name), to=exp.DataType.build("JSONB", dialect="postgres")
+                    )
+                ],
+            ),
+            alias=exp.TableAlias(
+                this=exp.to_identifier(recordset_alias),
+                columns=[
+                    exp.ColumnDef(
+                        this=exp.to_identifier(column),
+                        kind=exp.DataType.build(
+                            self._infer_postgres_type(sample_values.get(column)), dialect="postgres"
+                        ),
+                    )
+                    for column in columns
+                ],
+            ),
         )
 
-        parsed = sg.parse_one(from_sql, dialect="postgres")
+        parsed = exp.Select(
+            expressions=[exp.column(column) for column in columns], from_=exp.From(this=recordset_table)
+        )
         return exp.Subquery(
             this=parsed,
             alias=exp.TableAlias(
@@ -265,17 +282,26 @@ class MergeUsingClauseMixin(_MergeAssignmentMixin):
                 if value is not None and column not in sample_values:
                     sample_values[column] = value
 
-        json_columns = [
-            f"{column} {self._infer_oracle_type(sample_values.get(column))} PATH '$.{column}'" for column in columns
-        ]
-
         alias_name = alias or "src"
-        column_selects = ", ".join(columns)
-        columns_clause = ", ".join(json_columns)
-
-        from_sql = f"SELECT {column_selects} FROM JSON_TABLE(:{json_param_name}, '$[*]' COLUMNS ({columns_clause}))"
-
-        parsed = sg.parse_one(from_sql, dialect="oracle")
+        json_table = exp.Table(
+            this=exp.JSONTable(
+                this=exp.Placeholder(this=json_param_name),
+                path=exp.Literal.string("$[*]"),
+                schema=exp.JSONSchema(
+                    expressions=[
+                        exp.JSONColumnDef(
+                            this=exp.to_identifier(column),
+                            kind=exp.DataType.build(
+                                self._infer_oracle_type(sample_values.get(column)), dialect="oracle"
+                            ),
+                            path=exp.Literal.string(f"$.{column}"),
+                        )
+                        for column in columns
+                    ]
+                ),
+            )
+        )
+        parsed = exp.Select(expressions=[exp.column(column) for column in columns], from_=exp.From(this=json_table))
         return exp.Subquery(this=parsed, alias=exp.TableAlias(this=exp.to_identifier(alias_name)))
 
     def _infer_postgres_type(self, value: "Any") -> str:

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_parsing_utils.py

@@ -5,6 +5,7 @@ passed as strings to builder methods.
 """
 
 import contextlib
+import re
 from typing import TYPE_CHECKING, Any, Final
 
 from sqlglot import exp, maybe_parse
@@ -33,6 +34,47 @@ __all__ = (
 )
 
 ALIAS_PARTS_EXPECTED_COUNT = 2
+QUALIFIED_IDENTIFIER_PARTS = 2
+_SIMPLE_IDENTIFIER_RE: Final["re.Pattern[str]"] = re.compile(
+    r"^[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*){0,2}$"
+)
+_BARE_KEYWORDS: Final[frozenset[str]] = frozenset({
+    "all",
+    "and",
+    "any",
+    "asc",
+    "between",
+    "case",
+    "current_date",
+    "current_time",
+    "current_timestamp",
+    "current_user",
+    "default",
+    "delete",
+    "desc",
+    "distinct",
+    "end",
+    "exists",
+    "false",
+    "from",
+    "in",
+    "insert",
+    "interval",
+    "is",
+    "like",
+    "localtime",
+    "localtimestamp",
+    "not",
+    "null",
+    "or",
+    "select",
+    "session_user",
+    "some",
+    "true",
+    "update",
+    "user",
+    "where",
+})
 _PARAMETER_VALIDATOR = ParameterValidator()
 
 
@@ -69,6 +111,23 @@ def _merge_sql_parameters(sql_obj: Any, builder: Any) -> None:
         builder.add_parameter(param_value, name=param_name)
 
 
+def _is_simple_identifier(value: str) -> bool:
+    stripped = value.strip()
+    if not _SIMPLE_IDENTIFIER_RE.fullmatch(stripped):
+        return False
+    return "." in stripped or stripped.lower() not in _BARE_KEYWORDS
+
+
+def _simple_column_expression(value: str) -> exp.Column:
+    parts = value.strip().split(".")
+    identifiers = [exp.Identifier(this=part, quoted=False) for part in parts]
+    if len(parts) == 1:
+        return exp.Column(this=identifiers[0])
+    if len(parts) == QUALIFIED_IDENTIFIER_PARTS:
+        return exp.Column(this=identifiers[1], table=identifiers[0])
+    return exp.Column(this=identifiers[2], table=identifiers[1], db=identifiers[0])
+
+
 def parse_column_expression(column_input: str | exp.Expr | Any, builder: Any | None = None) -> exp.Expr:
     """Parse a column input that might be a complex expression.
 
@@ -92,6 +151,8 @@ def parse_column_expression(column_input: str | exp.Expr | Any, builder: Any | N
         return column_input
 
     if isinstance(column_input, str):
+        if _is_simple_identifier(column_input):
+            return _simple_column_expression(column_input)
         return exp.maybe_parse(column_input) or exp.column(column_input)
 
     if has_expression_and_sql(column_input):
@@ -126,6 +187,9 @@ def parse_table_expression(
             base_table, alias = parts
             return exp.to_table(base_table, alias=alias, dialect=dialect)
 
+    if _is_simple_identifier(table_input):
+        return exp.to_table(table_input, alias=explicit_alias, dialect=dialect)
+
     with contextlib.suppress(Exception):
         parsed: exp.Expr | None = exp.maybe_parse(f"SELECT * FROM {table_input}", dialect=dialect)
         if isinstance(parsed, exp.Select):
@@ -157,7 +221,17 @@ def parse_order_expression(order_input: str | exp.Expr) -> exp.Expr:
     if isinstance(order_input, exp.Expr):
         return order_input
 
-    parsed = maybe_parse(str(order_input), into=exp.Ordered)
+    order_value = str(order_input)
+    parts = order_value.rsplit(None, 1)
+    if len(parts) == ALIAS_PARTS_EXPECTED_COUNT and parts[1].lower() in {"asc", "desc"}:
+        base, direction = parts
+        if _is_simple_identifier(base):
+            column_expr = _simple_column_expression(base)
+            if direction.lower() == "desc":
+                return exp.Ordered(this=column_expr, desc=True, nulls_first=False)
+            return exp.Ordered(this=column_expr, desc=False, nulls_first=True)
+
+    parsed = maybe_parse(order_value, into=exp.Ordered)
     if parsed:
         return parsed
 

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_temporal.py

@@ -11,39 +11,37 @@ Supported syntax by dialect:
     - CockroachDB (Postgres): table AS OF SYSTEM TIME timestamp
 """
 
+from typing import TYPE_CHECKING
+
 from sqlglot import exp
-from sqlglot.dialects.bigquery import BigQuery
-from sqlglot.dialects.duckdb import DuckDB
-from sqlglot.dialects.oracle import Oracle
-from sqlglot.dialects.postgres import Postgres
-from sqlglot.dialects.snowflake import Snowflake
-from sqlglot.generator import (
-    _DISPATCH_CACHE,  # pyright: ignore[reportPrivateUsage]
-    Generator,
-)
-from sqlglot.generators.bigquery import BigQueryGenerator
-from sqlglot.generators.duckdb import DuckDBGenerator
-from sqlglot.generators.oracle import OracleGenerator
-from sqlglot.generators.postgres import PostgresGenerator
-from sqlglot.generators.snowflake import SnowflakeGenerator
+
+from sqlspec.builder._generation import invalidate_generator_dispatch
+
+if TYPE_CHECKING:
+    from sqlglot.generator import Generator
+    from sqlglot.generators.bigquery import BigQueryGenerator
+    from sqlglot.generators.duckdb import DuckDBGenerator
+    from sqlglot.generators.oracle import OracleGenerator
+    from sqlglot.generators.postgres import PostgresGenerator
+    from sqlglot.generators.snowflake import SnowflakeGenerator
 
 __all__ = ("create_temporal_table", "register_version_generators")
 
 
-def _oracle_version_sql(self: OracleGenerator, expression: exp.Version) -> str:
+def _oracle_version_sql(self: "OracleGenerator", expression: exp.Version) -> str:
     """Oracle: AS OF TIMESTAMP timestamp or AS OF SCN scn."""
     expr = self.sql(expression, "expression")
     this = expression.name or "TIMESTAMP"
     return f"AS OF {this} {expr}"
 
 
-def _bigquery_version_sql(self: BigQueryGenerator, expression: exp.Version) -> str:
+def _bigquery_version_sql(self: "BigQueryGenerator", expression: exp.Version) -> str:
     """BigQuery: FOR SYSTEM_TIME AS OF timestamp."""
     expr = self.sql(expression, "expression")
     return f"FOR SYSTEM_TIME AS OF {expr}"
 
 
-def _snowflake_version_sql(self: SnowflakeGenerator, expression: exp.Version) -> str:
+def _snowflake_version_sql(self: "SnowflakeGenerator", expression: exp.Version) -> str:
     """Snowflake: AT (TIMESTAMP => timestamp) or BEFORE (TIMESTAMP => ...).
 
     AS OF is mapped to AT, and BEFORE is supported for point-before queries.
@@ -56,19 +54,19 @@ def _snowflake_version_sql(self: SnowflakeGenerator, expression: exp.Version) ->
     return f"AT ({this} => {expr})"
 
 
-def _duckdb_version_sql(self: DuckDBGenerator, expression: exp.Version) -> str:
+def _duckdb_version_sql(self: "DuckDBGenerator", expression: exp.Version) -> str:
     """DuckDB: AT (TIMESTAMP => timestamp)."""
     expr = self.sql(expression, "expression")
     return f"AT (TIMESTAMP => {expr})"
 
 
-def _cockroachdb_version_sql(self: PostgresGenerator, expression: exp.Version) -> str:
+def _cockroachdb_version_sql(self: "PostgresGenerator", expression: exp.Version) -> str:
     """CockroachDB (via Postgres dialect): AS OF SYSTEM TIME timestamp."""
     expr = self.sql(expression, "expression")
     return f"AS OF SYSTEM TIME {expr}"
 
 
-def _default_version_sql(self: Generator, expression: exp.Version) -> str:
+def _default_version_sql(self: "Generator", expression: exp.Version) -> str:
     """Default: AS OF SYSTEM TIME timestamp (CockroachDB style).
 
     When no dialect is specified, we default to CockroachDB/Postgres style
@@ -92,6 +90,8 @@ def create_temporal_table(
     Returns:
         Table expression with version clause that generates dialect-specific SQL.
     """
+    register_version_generators()
+
     if isinstance(table, str):
         table_expr = exp.to_table(table)
     elif isinstance(table, exp.Table):
@@ -129,6 +129,13 @@ def register_version_generators() -> None:
     if _VERSION_GENERATORS_REGISTERED:
         return
 
+    from sqlglot.dialects.bigquery import BigQuery
+    from sqlglot.dialects.duckdb import DuckDB
+    from sqlglot.dialects.oracle import Oracle
+    from sqlglot.dialects.postgres import Postgres
+    from sqlglot.dialects.snowflake import Snowflake
+    from sqlglot.generator import Generator
+
     Generator.TRANSFORMS[exp.Version] = _default_version_sql
 
     BigQuery.Generator.TRANSFORMS[exp.Version] = _bigquery_version_sql
@@ -137,16 +144,8 @@ def register_version_generators() -> None:
     DuckDB.Generator.TRANSFORMS[exp.Version] = _duckdb_version_sql
     Postgres.Generator.TRANSFORMS[exp.Version] = _cockroachdb_version_sql
 
-    # Invalidate sqlglot's per-class dispatch cache so new TRANSFORMS entries
-    # are picked up by the next Generator instantiation.
-    for gen_cls in (
-        Generator,
-        BigQuery.Generator,
-        Oracle.Generator,
-        Snowflake.Generator,
-        DuckDB.Generator,
-        Postgres.Generator,
-    ):
-        _DISPATCH_CACHE.pop(gen_cls, None)
+    invalidate_generator_dispatch(
+        Generator, BigQuery.Generator, Oracle.Generator, Snowflake.Generator, DuckDB.Generator, Postgres.Generator
+    )
 
     _VERSION_GENERATORS_REGISTERED = True

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/builder/_vector_distance.py

@@ -7,6 +7,8 @@ from typing import TYPE_CHECKING, Any, Final, cast
 
 from sqlglot import exp
 
+from sqlspec.builder._generation import invalidate_generator_dispatch
+
 if TYPE_CHECKING:
     from sqlglot.generator import Generator
 
@@ -271,19 +273,8 @@ def _register_with_sqlglot() -> None:
     _register_operator_transform(BigQuery.Generator.TRANSFORMS, _operator_sql_bigquery)
     _register_operator_transform(DuckDB.Generator.TRANSFORMS, _operator_sql_duckdb)
 
-    # sqlglot caches the dispatch table (built from TRANSFORMS) per Generator class
-    # in _DISPATCH_CACHE. We must invalidate stale entries so the next instantiation
-    # picks up our new Operator transforms.
-    from sqlglot.generator import _DISPATCH_CACHE  # pyright: ignore[reportPrivateUsage]
-
-    for gen_cls in (
-        Generator,
-        Postgres.Generator,
-        MySQL.Generator,
-        Oracle.Generator,
-        BigQuery.Generator,
-        DuckDB.Generator,
-    ):
-        _DISPATCH_CACHE.pop(gen_cls, None)
+    invalidate_generator_dispatch(
+        Generator, Postgres.Generator, MySQL.Generator, Oracle.Generator, BigQuery.Generator, DuckDB.Generator
+    )
 
     _SQLGLOT_VECTOR_DISTANCE_REGISTERED = True

{sqlspec-0.50.0 → sqlspec-0.50.1}/sqlspec/core/statement.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Final, TypeAlias
 
 import sqlglot
 from mypy_extensions import mypyc_attr
-from sqlglot import exp
+from sqlglot import Dialect, exp
 from sqlglot.errors import ParseError
 
 import sqlspec.exceptions
@@ -464,7 +464,9 @@ class SQL:
             return None
         if isinstance(dialect, str):
             return dialect
-        return dialect.__class__.__name__.lower()
+        if isinstance(dialect, type) and issubclass(dialect, Dialect):
+            return dialect.__name__.lower()
+        return type(dialect).__name__.lower()
 
     def _get_raw_sql(self) -> str:
         """Return raw SQL, materializing deferred expression SQL when needed."""