sqlspec 0.54.1__tar.gz → 0.54.2__tar.gz

{sqlspec-0.54.1 → sqlspec-0.54.2}/PKG-INFO

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

{sqlspec-0.54.1 → sqlspec-0.54.2}/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.54.1"
+version = "0.54.2"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -197,7 +197,6 @@ packages = ["sqlspec"]
 # Keep that smoke build from auto-discovering ignored scratch directories.
 packages = []
 
-
 [tool.hatch.build.targets.wheel.hooks.mypyc]
 dependencies = ["hatch-mypyc", "hatch-cython", "mypy>=2.0.0"]
 enable-by-default = false
@@ -308,7 +307,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.54.1"
+current_version = "0.54.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/adapters/aiosqlite/driver.py

@@ -26,7 +26,13 @@ from sqlspec.adapters.aiosqlite.core import (
 from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteDataDictionary
 from sqlspec.core import ArrowResult, ParameterStyle, TypedParameter, get_cache_config, register_driver_profile
 from sqlspec.core.result import DMLResult
-from sqlspec.driver import AsyncDriverAdapterBase, AsyncRowStream, BaseAsyncExceptionHandler
+from sqlspec.driver import (
+    AsyncDriverAdapterBase,
+    AsyncRowStream,
+    BaseAsyncExceptionHandler,
+    parameter_value_needs_processing,
+    type_coercion_fallbacks,
+)
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.utils.type_guards import resolve_row_format
 
@@ -259,6 +265,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         row_len = len(first_sequence)
         coercion_map = type_coercion_map
         has_type_coercion = bool(coercion_map)
+        fallback_items = type_coercion_fallbacks(coercion_map) if coercion_map else ()
 
         if row_len == 1:
             if has_type_coercion and coercion_map is not None:
@@ -268,8 +275,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
                         return False
                     if len(sequence) != 1:
                         return False
-                    value_type = type(sequence[0])
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(sequence[0], coercion_map, fallback_items):
                         return False
                 return True
 
@@ -291,8 +297,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
                 if len(sequence) != row_len:
                     return False
                 for value in sequence:
-                    value_type = type(value)
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(value, coercion_map, fallback_items):
                         return False
             return True
 

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/adapters/oracledb/litestar/store.py

@@ -1,6 +1,6 @@
 """Oracle session store for Litestar integration."""
 
-from datetime import datetime, timedelta, timezone
+from datetime import timedelta, timezone
 from typing import TYPE_CHECKING
 
 from sqlspec.extensions.litestar.store import BaseSQLSpecStore
@@ -16,6 +16,17 @@ __all__ = ("OracleAsyncStore", "OracleSyncStore")
 ORACLE_SMALL_BLOB_LIMIT = 32000
 
 
+def _oracle_expiry_seconds(expires_in: "int | timedelta | None") -> "int | None":
+    """Convert a session TTL value to whole seconds for Oracle interval binds."""
+    if expires_in is None:
+        return None
+
+    expires_in_seconds = int(expires_in.total_seconds()) if isinstance(expires_in, timedelta) else int(expires_in)
+    if expires_in_seconds <= 0:
+        return None
+    return expires_in_seconds
+
+
 def _coerce_bytes_payload(value: object) -> bytes:
     """Coerce a payload into bytes for session storage."""
     if value is None:
@@ -170,14 +181,18 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             data_blob, expires_at = row
 
             if renew_for is not None and expires_at is not None:
-                new_expires_at = self._calculate_expires_at(renew_for)
-                if new_expires_at is not None:
+                expires_in_seconds = _oracle_expiry_seconds(renew_for)
+                if expires_in_seconds is not None:
                     update_sql = f"""
                     UPDATE {self._table_name}
-                    SET expires_at = :expires_at, updated_at = SYSTIMESTAMP
+                    SET expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        updated_at = SYSTIMESTAMP
                     WHERE session_id = :session_id
                     """
-                    await cursor.execute(update_sql, {"expires_at": new_expires_at, "session_id": key})
+                    await cursor.execute(update_sql, {"expires_in_seconds": expires_in_seconds, "session_id": key})
                     await conn.commit()
 
             return await _read_blob_async(data_blob)
@@ -191,7 +206,7 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             expires_in: Time until expiration.
         """
         data = self._value_to_bytes(value)
-        expires_at = self._calculate_expires_at(expires_in)
+        expires_in_seconds = _oracle_expiry_seconds(expires_in)
 
         conn_context = self._config.provide_connection()
         async with conn_context as conn:
@@ -205,13 +220,25 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = EMPTY_BLOB(),
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, EMPTY_BLOB(), :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        EMPTY_BLOB(),
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                await cursor.execute(merge_sql, {"session_id": key, "expires_at": expires_at})
+                await cursor.execute(merge_sql, {"session_id": key, "expires_in_seconds": expires_in_seconds})
 
                 select_sql = f"""
                 SELECT data FROM {self._table_name}
@@ -232,13 +259,25 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = :data,
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, :data, :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        :data,
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                await cursor.execute(sql, {"session_id": key, "data": data, "expires_at": expires_at})
+                await cursor.execute(sql, {"session_id": key, "data": data, "expires_in_seconds": expires_in_seconds})
                 await conn.commit()
 
     async def delete(self, key: str) -> None:
@@ -298,7 +337,7 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             Seconds until expiration, or None if no expiry or key doesn't exist.
         """
         sql = f"""
-        SELECT expires_at FROM {self._table_name}
+        SELECT expires_at, SYSTIMESTAMP FROM {self._table_name}
         WHERE session_id = :session_id
         """
 
@@ -311,17 +350,17 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             if row is None or row[0] is None:
                 return None
 
-            expires_at = row[0]
+            expires_at, db_now = row
 
             if expires_at.tzinfo is None:
                 expires_at = expires_at.replace(tzinfo=timezone.utc)
+            if db_now.tzinfo is None:
+                db_now = db_now.replace(tzinfo=timezone.utc)
 
-            now = datetime.now(timezone.utc)
-
-            if expires_at <= now:
+            if expires_at <= db_now:
                 return 0
 
-            delta = expires_at - now
+            delta = expires_at - db_now
             return int(delta.total_seconds())
 
     async def delete_expired(self) -> int:
@@ -468,14 +507,18 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
             data_blob, expires_at = row
 
             if renew_for is not None and expires_at is not None:
-                new_expires_at = self._calculate_expires_at(renew_for)
-                if new_expires_at is not None:
+                expires_in_seconds = _oracle_expiry_seconds(renew_for)
+                if expires_in_seconds is not None:
                     update_sql = f"""
                     UPDATE {self._table_name}
-                    SET expires_at = :expires_at, updated_at = SYSTIMESTAMP
+                    SET expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        updated_at = SYSTIMESTAMP
                     WHERE session_id = :session_id
                     """
-                    cursor.execute(update_sql, {"expires_at": new_expires_at, "session_id": key})
+                    cursor.execute(update_sql, {"expires_in_seconds": expires_in_seconds, "session_id": key})
                     conn.commit()
 
             return _read_blob_sync(data_blob)
@@ -495,7 +538,7 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
     def _set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
         """Synchronous implementation of set."""
         data = self._value_to_bytes(value)
-        expires_at = self._calculate_expires_at(expires_in)
+        expires_in_seconds = _oracle_expiry_seconds(expires_in)
 
         with self._config.provide_connection() as conn:
             cursor = conn.cursor()
@@ -508,13 +551,25 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = EMPTY_BLOB(),
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, EMPTY_BLOB(), :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        EMPTY_BLOB(),
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                cursor.execute(merge_sql, {"session_id": key, "expires_at": expires_at})
+                cursor.execute(merge_sql, {"session_id": key, "expires_in_seconds": expires_in_seconds})
 
                 select_sql = f"""
                 SELECT data FROM {self._table_name}
@@ -535,13 +590,25 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = :data,
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, :data, :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        :data,
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                cursor.execute(sql, {"session_id": key, "data": data, "expires_at": expires_at})
+                cursor.execute(sql, {"session_id": key, "data": data, "expires_in_seconds": expires_in_seconds})
                 conn.commit()
 
     async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
@@ -613,7 +680,7 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
     def _expires_in(self, key: str) -> "int | None":
         """Synchronous implementation of expires_in."""
         sql = f"""
-        SELECT expires_at FROM {self._table_name}
+        SELECT expires_at, SYSTIMESTAMP FROM {self._table_name}
         WHERE session_id = :session_id
         """
 
@@ -625,17 +692,17 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
             if row is None or row[0] is None:
                 return None
 
-            expires_at = row[0]
+            expires_at, db_now = row
 
             if expires_at.tzinfo is None:
                 expires_at = expires_at.replace(tzinfo=timezone.utc)
+            if db_now.tzinfo is None:
+                db_now = db_now.replace(tzinfo=timezone.utc)
 
-            now = datetime.now(timezone.utc)
-
-            if expires_at <= now:
+            if expires_at <= db_now:
                 return 0
 
-            delta = expires_at - now
+            delta = expires_at - db_now
             return int(delta.total_seconds())
 
     async def expires_in(self, key: str) -> "int | None":

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/adapters/psqlpy/core.py

@@ -644,7 +644,7 @@ def build_insert_statement(table: str, columns: "list[str]") -> str:
 
 def _sequence_needs_numeric_coercion(values: "list[Any] | tuple[Any, ...]") -> bool:
     """Return True when any value in a parameter sequence needs numeric coercion."""
-    return any(type(value) in _NUMERIC_COERCE_TYPES for value in values)
+    return any(isinstance(value, _NUMERIC_COERCE_TYPES) for value in values)
 
 
 def _format_execute_many_param_set(param_set: Any, *, coerce_numeric: bool) -> "list[Any]":

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/adapters/sqlite/driver.py

@@ -19,7 +19,13 @@ from sqlspec.adapters.sqlite.core import (
 from sqlspec.adapters.sqlite.data_dictionary import SqliteDataDictionary
 from sqlspec.core import ArrowResult, ParameterStyle, TypedParameter, get_cache_config, register_driver_profile
 from sqlspec.core.result import DMLResult
-from sqlspec.driver import BaseSyncExceptionHandler, SyncDriverAdapterBase, SyncRowStream
+from sqlspec.driver import (
+    BaseSyncExceptionHandler,
+    SyncDriverAdapterBase,
+    SyncRowStream,
+    parameter_value_needs_processing,
+    type_coercion_fallbacks,
+)
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.utils.type_guards import resolve_row_format
 
@@ -284,6 +290,7 @@ class SqliteDriver(SyncDriverAdapterBase):
         row_len = len(first_sequence)
         coercion_map = type_coercion_map
         has_type_coercion = bool(coercion_map)
+        fallback_items = type_coercion_fallbacks(coercion_map) if coercion_map else ()
 
         # Common benchmark shape: list[tuple[value]]
         if row_len == 1:
@@ -294,8 +301,7 @@ class SqliteDriver(SyncDriverAdapterBase):
                         return False
                     if len(sequence) != 1:
                         return False
-                    value_type = type(sequence[0])
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(sequence[0], coercion_map, fallback_items):
                         return False
                 return True
 
@@ -317,8 +323,7 @@ class SqliteDriver(SyncDriverAdapterBase):
                 if len(sequence) != row_len:
                     return False
                 for value in sequence:
-                    value_type = type(value)
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(value, coercion_map, fallback_items):
                         return False
             return True
 

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/core/cache.py

@@ -30,6 +30,8 @@ if TYPE_CHECKING:
 
     import sqlglot.expressions as exp
 
+    from sqlspec.core.parameters import ParameterProfile
+
 
 __all__ = (
     "CacheConfig",
@@ -581,24 +583,40 @@ class CachedStatement:
     where drivers require list type.
     """
 
-    __slots__ = ("compiled_sql", "expression", "parameters")
+    __slots__ = (
+        "applied_wrap_types",
+        "compiled_sql",
+        "expression",
+        "input_named_parameters",
+        "parameter_profile",
+        "parameters",
+    )
 
     def __init__(
         self,
         compiled_sql: str,
         parameters: "tuple[Any, ...] | list[Any] | dict[str, Any] | None",
         expression: "exp.Expr | None",
+        input_named_parameters: "tuple[str, ...] | None" = None,
+        parameter_profile: "ParameterProfile | None" = None,
+        applied_wrap_types: bool = False,
     ) -> None:
+        self.applied_wrap_types = applied_wrap_types
         self.compiled_sql = compiled_sql
-        self.parameters = parameters
         self.expression = expression
+        self.input_named_parameters = input_named_parameters or ()
+        self.parameter_profile = parameter_profile
+        self.parameters = parameters
 
     def __repr__(self) -> str:
         return (
             "CachedStatement("
             f"compiled_sql={self.compiled_sql!r}, "
             f"parameters={self.parameters!r}, "
-            f"expression={self.expression!r})"
+            f"expression={self.expression!r}, "
+            f"input_named_parameters={self.input_named_parameters!r}, "
+            f"parameter_profile={self.parameter_profile!r}, "
+            f"applied_wrap_types={self.applied_wrap_types!r})"
         )
 
     def __eq__(self, other: object) -> bool:
@@ -608,10 +626,20 @@ class CachedStatement:
             self.compiled_sql == other.compiled_sql
             and self.parameters == other.parameters
             and self.expression == other.expression
+            and self.input_named_parameters == other.input_named_parameters
+            and self.parameter_profile == other.parameter_profile
+            and self.applied_wrap_types == other.applied_wrap_types
         )
 
     def __hash__(self) -> int:
-        return hash((self.compiled_sql, self.parameters, self.expression))
+        return hash((
+            self.compiled_sql,
+            self.parameters,
+            self.expression,
+            self.input_named_parameters,
+            self.parameter_profile,
+            self.applied_wrap_types,
+        ))
 
 
 def create_cache_key(namespace: str, key: str, dialect: str | None = None) -> str:

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/core/statement.py

@@ -1021,12 +1021,25 @@ class SQL:
     def _current_expression(self) -> exp.Expr:
         """Get the current expression or parse the raw SQL.
 
-        Prefers cached parsed expression over re-parsing raw SQL.
+        Preserves authoring-time parameter names for dynamic query modifiers,
+        then falls back to cached parsed expressions.
 
         Returns:
             The SQLGlot expression for this statement
         """
-        # First check processed state for parsed expression
+        # Preserve authoring-time parameter names when applying dynamic query modifiers.
+        if (
+            self._processed_state is not Empty
+            and self._processed_state.input_named_parameters
+            and self._raw_expression is None
+            and self._raw_sql
+        ):
+            try:
+                parsed = sqlglot.parse_one(self._raw_sql, dialect=self._dialect)
+                if isinstance(parsed, exp.Expr):
+                    return parsed
+            except ParseError:
+                pass
         if self._processed_state is not Empty and self._processed_state.parsed_expression is not None:
             return self._processed_state.parsed_expression.copy()
         # Then check statement_expression (from compilation)

{sqlspec-0.54.1 → sqlspec-0.54.2}/sqlspec/data_dictionary/__init__.py

@@ -9,33 +9,81 @@ from sqlspec.data_dictionary._registry import (
     register_dialect,
 )
 from sqlspec.data_dictionary._types import (
+    ColumnDetails,
     ColumnMetadata,
+    CommentMetadata,
+    ConstraintMetadata,
+    DDLResult,
+    DependencyMetadata,
     DialectConfig,
     FeatureFlags,
     FeatureVersions,
     ForeignKeyMetadata,
+    IndexDetails,
     IndexMetadata,
+    MetadataCapability,
+    MetadataCapabilityProfile,
+    MetadataFidelity,
+    MetadataQuery,
+    MetadataResult,
+    MetadataRisk,
+    MetadataSource,
+    MetadataSupport,
+    ObjectIdentity,
+    ObjectMetadata,
+    PartitionMetadata,
+    PrivilegeMetadata,
+    RoutineMetadata,
+    SchemaMetadata,
+    SystemMetadata,
+    TableDetails,
     TableMetadata,
     TableStatisticsMetadata,
+    TriggerMetadata,
     VersionCacheResult,
     VersionInfo,
+    ViewMetadata,
 )
 
 if TYPE_CHECKING:
     from sqlspec.data_dictionary._loader import DataDictionaryLoader, get_data_dictionary_loader
 
 __all__ = (
+    "ColumnDetails",
     "ColumnMetadata",
+    "CommentMetadata",
+    "ConstraintMetadata",
+    "DDLResult",
     "DataDictionaryLoader",
+    "DependencyMetadata",
     "DialectConfig",
     "FeatureFlags",
     "FeatureVersions",
     "ForeignKeyMetadata",
+    "IndexDetails",
     "IndexMetadata",
+    "MetadataCapability",
+    "MetadataCapabilityProfile",
+    "MetadataFidelity",
+    "MetadataQuery",
+    "MetadataResult",
+    "MetadataRisk",
+    "MetadataSource",
+    "MetadataSupport",
+    "ObjectIdentity",
+    "ObjectMetadata",
+    "PartitionMetadata",
+    "PrivilegeMetadata",
+    "RoutineMetadata",
+    "SchemaMetadata",
+    "SystemMetadata",
+    "TableDetails",
     "TableMetadata",
     "TableStatisticsMetadata",
+    "TriggerMetadata",
     "VersionCacheResult",
     "VersionInfo",
+    "ViewMetadata",
     "get_data_dictionary_loader",
     "get_dialect_config",
     "list_registered_dialects",