sqlspec 0.13.1__py3-none-any.whl → 0.16.2__py3-none-any.whl

sqlspec/base.py

@@ -13,6 +13,15 @@ from sqlspec.config import (
     SyncConfigT,
     SyncDatabaseConfig,
 )
+from sqlspec.core.cache import (
+    CacheConfig,
+    CacheStatsAggregate,
+    get_cache_config,
+    get_cache_stats,
+    log_cache_stats,
+    reset_cache_stats,
+    update_cache_config,
+)
 from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
@@ -27,18 +36,19 @@ logger = get_logger()
 
 
 class SQLSpec:
-    """Type-safe configuration manager and registry for database connections and pools."""
+    """Configuration manager and registry for database connections and pools."""
 
-    __slots__ = ("_configs",)
+    __slots__ = ("_cleanup_tasks", "_configs", "_instance_cache_config")
 
     def __init__(self) -> None:
         self._configs: dict[Any, DatabaseConfigProtocol[Any, Any, Any]] = {}
         atexit.register(self._cleanup_pools)
+        self._instance_cache_config: Optional[CacheConfig] = None
+        self._cleanup_tasks: list[asyncio.Task[None]] = []
 
     @staticmethod
     def _get_config_name(obj: Any) -> str:
         """Get display name for configuration object."""
-        # Try to get __name__ attribute if it exists, otherwise use str()
         return getattr(obj, "__name__", str(obj))
 
     def _cleanup_pools(self) -> None:
@@ -54,11 +64,11 @@ class SQLSpec:
                             try:
                                 loop = asyncio.get_running_loop()
                                 if loop.is_running():
-                                    _task = asyncio.ensure_future(close_pool_awaitable, loop=loop)  # noqa: RUF006
-
+                                    task = asyncio.create_task(cast("Coroutine[Any, Any, None]", close_pool_awaitable))
+                                    self._cleanup_tasks.append(task)
                                 else:
                                     asyncio.run(cast("Coroutine[Any, Any, None]", close_pool_awaitable))
-                            except RuntimeError:  # No running event loop
+                            except RuntimeError:
                                 asyncio.run(cast("Coroutine[Any, Any, None]", close_pool_awaitable))
                     else:
                         config.close_pool()
@@ -66,6 +76,14 @@ class SQLSpec:
                 except Exception as e:
                     logger.warning("Failed to clean up pool for config %s: %s", config_type.__name__, e)
 
+        if self._cleanup_tasks:
+            try:
+                loop = asyncio.get_running_loop()
+                if loop.is_running():
+                    asyncio.gather(*self._cleanup_tasks, return_exceptions=True)
+            except RuntimeError:
+                pass
+
         self._configs.clear()
         logger.info("Pool cleanup completed. Cleaned %d pools.", cleaned_count)
 
@@ -233,14 +251,13 @@ class SQLSpec:
             async def _create_driver_async() -> "DriverT":
                 resolved_connection = await connection_obj  # pyright: ignore
                 return cast(  # pyright: ignore
-                    "DriverT",
-                    config.driver_type(connection=resolved_connection, default_row_type=config.default_row_type),
+                    "DriverT", config.driver_type(connection=resolved_connection)
                 )
 
             return _create_driver_async()
 
         return cast(  # pyright: ignore
-            "DriverT", config.driver_type(connection=connection_obj, default_row_type=config.default_row_type)
+            "DriverT", config.driver_type(connection=connection_obj)
         )
 
     @overload
@@ -473,3 +490,82 @@ class SQLSpec:
 
         logger.debug("Config %s does not support connection pooling - nothing to close", config_name)
         return None
+
+    @staticmethod
+    def get_cache_config() -> CacheConfig:
+        """Get the current global cache configuration.
+
+        Returns:
+            The current cache configuration.
+        """
+        return get_cache_config()
+
+    @staticmethod
+    def update_cache_config(config: CacheConfig) -> None:
+        """Update the global cache configuration.
+
+        Args:
+            config: The new cache configuration to apply.
+        """
+        update_cache_config(config)
+
+    @staticmethod
+    def get_cache_stats() -> CacheStatsAggregate:
+        """Get current cache statistics.
+
+        Returns:
+            Cache statistics object with detailed metrics.
+        """
+        return get_cache_stats()
+
+    @staticmethod
+    def reset_cache_stats() -> None:
+        """Reset all cache statistics to zero."""
+        reset_cache_stats()
+
+    @staticmethod
+    def log_cache_stats() -> None:
+        """Log current cache statistics using the configured logger."""
+        log_cache_stats()
+
+    @staticmethod
+    def configure_cache(
+        *,
+        sql_cache_size: Optional[int] = None,
+        fragment_cache_size: Optional[int] = None,
+        optimized_cache_size: Optional[int] = None,
+        sql_cache_enabled: Optional[bool] = None,
+        fragment_cache_enabled: Optional[bool] = None,
+        optimized_cache_enabled: Optional[bool] = None,
+    ) -> None:
+        """Update cache configuration with partial values.
+
+        Args:
+            sql_cache_size: Size of the SQL statement cache
+            fragment_cache_size: Size of the AST fragment cache
+            optimized_cache_size: Size of the optimized expression cache
+            sql_cache_enabled: Enable/disable SQL cache
+            fragment_cache_enabled: Enable/disable fragment cache
+            optimized_cache_enabled: Enable/disable optimized cache
+        """
+        current_config = get_cache_config()
+        update_cache_config(
+            CacheConfig(
+                sql_cache_size=sql_cache_size if sql_cache_size is not None else current_config.sql_cache_size,
+                fragment_cache_size=fragment_cache_size
+                if fragment_cache_size is not None
+                else current_config.fragment_cache_size,
+                optimized_cache_size=optimized_cache_size
+                if optimized_cache_size is not None
+                else current_config.optimized_cache_size,
+                sql_cache_enabled=sql_cache_enabled
+                if sql_cache_enabled is not None
+                else current_config.sql_cache_enabled,
+                fragment_cache_enabled=fragment_cache_enabled
+                if fragment_cache_enabled is not None
+                else current_config.fragment_cache_enabled,
+                optimized_cache_enabled=optimized_cache_enabled
+                if optimized_cache_enabled is not None
+                else current_config.optimized_cache_enabled,
+            )
+        )

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

@@ -2,14 +2,11 @@
 
 This package provides fluent interfaces for building SQL queries with automatic
 parameter binding and validation.
-
-# SelectBuilder is now generic and supports as_schema for type-safe schema integration.
 """
 
-from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.builder.base import QueryBuilder, SafeQuery
-from sqlspec.statement.builder.column import Column, ColumnExpression, FunctionColumn
-from sqlspec.statement.builder.ddl import (
+from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder._column import Column, ColumnExpression, FunctionColumn
+from sqlspec.builder._ddl import (
     AlterTable,
     CommentOn,
     CreateIndex,
@@ -24,14 +21,15 @@ from sqlspec.statement.builder.ddl import (
     DropTable,
     DropView,
     RenameTable,
-    TruncateTable,
+    Truncate,
 )
-from sqlspec.statement.builder.delete import Delete
-from sqlspec.statement.builder.insert import Insert
-from sqlspec.statement.builder.merge import Merge
-from sqlspec.statement.builder.mixins import WhereClauseMixin
-from sqlspec.statement.builder.select import Select
-from sqlspec.statement.builder.update import Update
+from sqlspec.builder._delete import Delete
+from sqlspec.builder._insert import Insert
+from sqlspec.builder._merge import Merge
+from sqlspec.builder._select import Select
+from sqlspec.builder._update import Update
+from sqlspec.builder.mixins import WhereClauseMixin
+from sqlspec.exceptions import SQLBuilderError
 
 __all__ = (
     "AlterTable",
@@ -58,7 +56,7 @@ __all__ = (
     "SQLBuilderError",
     "SafeQuery",
     "Select",
-    "TruncateTable",
+    "Truncate",
     "Update",
     "WhereClauseMixin",
 )

sqlspec/{statement/builder/base.py → builder/_base.py}

@@ -1,13 +1,11 @@
 """Safe SQL query builder with validation and parameter binding.
 
 This module provides a fluent interface for building SQL queries safely,
-with automatic parameter binding and validation. Enhanced with SQLGlot's
-advanced builder patterns and optimization capabilities.
+with automatic parameter binding and validation.
 """
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generic, NoReturn, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, NoReturn, Optional, Union, cast
 
 import sqlglot
 from sqlglot import Dialect, exp
@@ -16,59 +14,81 @@ from sqlglot.errors import ParseError as SQLGlotParseError
 from sqlglot.optimizer import optimize
 from typing_extensions import Self
 
+from sqlspec.core.cache import CacheKey, get_cache_config, get_default_cache
+from sqlspec.core.hashing import hash_optimized_expression
+from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
+from sqlspec.core.statement import SQL, StatementConfig
 from sqlspec.exceptions import SQLBuilderError
-from sqlspec.statement.sql import SQL, SQLConfig
-from sqlspec.typing import RowT
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.type_guards import has_sql_method, has_with_method
 
 if TYPE_CHECKING:
-    from sqlspec.statement.result import SQLResult
+    from sqlspec.core.result import SQLResult
 
 __all__ = ("QueryBuilder", "SafeQuery")
 
 logger = get_logger(__name__)
 
 
-@dataclass(frozen=True)
 class SafeQuery:
     """A safely constructed SQL query with bound parameters."""
 
-    sql: str
-    parameters: dict[str, Any] = field(default_factory=dict)
-    dialect: DialectType = field(default=None)
+    __slots__ = ("dialect", "parameters", "sql")
 
+    def __init__(
+        self, sql: str, parameters: Optional[dict[str, Any]] = None, dialect: Optional[DialectType] = None
+    ) -> None:
+        self.sql = sql
+        self.parameters = parameters if parameters is not None else {}
+        self.dialect = dialect
 
-@dataclass
-class QueryBuilder(ABC, Generic[RowT]):
+
+class QueryBuilder(ABC):
     """Abstract base class for SQL query builders with SQLGlot optimization.
 
     Provides common functionality for dialect handling, parameter management,
-    query construction, and automatic query optimization using SQLGlot's
-    advanced capabilities.
-
-    New features:
-    - Automatic query optimization (join reordering, predicate pushdown)
-    - Query complexity analysis
-    - Smart parameter naming based on context
-    - Expression caching for performance
+    query construction, and query optimization using SQLGlot.
     """
 
-    dialect: DialectType = field(default=None)
-    schema: Optional[dict[str, dict[str, str]]] = field(default=None)
-    _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
-    _parameters: dict[str, Any] = field(default_factory=dict, init=False, repr=False, compare=False, hash=False)
-    _parameter_counter: int = field(default=0, init=False, repr=False, compare=False, hash=False)
-    _with_ctes: dict[str, exp.CTE] = field(default_factory=dict, init=False, repr=False, compare=False, hash=False)
-    enable_optimization: bool = field(default=True, init=True)
-    optimize_joins: bool = field(default=True, init=True)
-    optimize_predicates: bool = field(default=True, init=True)
-    simplify_expressions: bool = field(default=True, init=True)
-
-    def __post_init__(self) -> None:
+    __slots__ = (
+        "_expression",
+        "_parameter_counter",
+        "_parameters",
+        "_with_ctes",
+        "dialect",
+        "enable_optimization",
+        "optimize_joins",
+        "optimize_predicates",
+        "schema",
+        "simplify_expressions",
+    )
+
+    def __init__(
+        self,
+        dialect: Optional[DialectType] = None,
+        schema: Optional[dict[str, dict[str, str]]] = None,
+        enable_optimization: bool = True,
+        optimize_joins: bool = True,
+        optimize_predicates: bool = True,
+        simplify_expressions: bool = True,
+    ) -> None:
+        self.dialect = dialect
+        self.schema = schema
+        self.enable_optimization = enable_optimization
+        self.optimize_joins = optimize_joins
+        self.optimize_predicates = optimize_predicates
+        self.simplify_expressions = simplify_expressions
+
+        # Initialize mutable attributes
+        self._expression: Optional[exp.Expression] = None
+        self._parameters: dict[str, Any] = {}
+        self._parameter_counter: int = 0
+        self._with_ctes: dict[str, exp.CTE] = {}
+
+    def _initialize_expression(self) -> None:
+        """Initialize the base expression. Called after __init__."""
         self._expression = self._create_base_expression()
         if not self._expression:
-            # This path should be unreachable if _raise_sql_builder_error has NoReturn
             self._raise_sql_builder_error(
                 "QueryBuilder._create_base_expression must return a valid sqlglot expression."
             )
@@ -77,17 +97,13 @@ class QueryBuilder(ABC, Generic[RowT]):
     def _create_base_expression(self) -> exp.Expression:
         """Create the base sqlglot expression for the specific query type.
 
-        Examples:
-            For a SELECT query, this would return `exp.Select()`.
-            For an INSERT query, this would return `exp.Insert()`.
-
         Returns:
-            exp.Expression: A new sqlglot expression.
+            A new sqlglot expression appropriate for the query type.
         """
 
     @property
     @abstractmethod
-    def _expected_result_type(self) -> "type[SQLResult[RowT]]":
+    def _expected_result_type(self) -> "type[SQLResult]":
         """The expected result type for the query being built.
 
         Returns:
@@ -119,7 +135,6 @@ class QueryBuilder(ABC, Generic[RowT]):
         """
         self._parameter_counter += 1
 
-        # Use context-aware naming if provided
         param_name = f"{context}_param_{self._parameter_counter}" if context else f"param_{self._parameter_counter}"
 
         self._parameters[param_name] = value
@@ -141,15 +156,13 @@ class QueryBuilder(ABC, Generic[RowT]):
 
         def replacer(node: exp.Expression) -> exp.Expression:
             if isinstance(node, exp.Literal):
-                # Skip boolean literals (TRUE/FALSE) and NULL
-                if node.this in (True, False, None):
+                if node.this in {True, False, None}:
                     return node
-                # Convert other literals to parameters
                 param_name = self._add_parameter(node.this, context="where")
                 return exp.Placeholder(this=param_name)
             return node
 
-        return expression.transform(replacer, copy=True)
+        return expression.transform(replacer, copy=False)
 
     def add_parameter(self: Self, value: Any, name: Optional[str] = None) -> tuple[Self, str]:
         """Explicitly adds a parameter to the query.
@@ -168,13 +181,13 @@ class QueryBuilder(ABC, Generic[RowT]):
         if name:
             if name in self._parameters:
                 self._raise_sql_builder_error(f"Parameter name '{name}' already exists.")
-            param_name_to_use = name
-        else:
-            self._parameter_counter += 1
-            param_name_to_use = f"param_{self._parameter_counter}"
+            self._parameters[name] = value
+            return self, name
 
-        self._parameters[param_name_to_use] = value
-        return self, param_name_to_use
+        self._parameter_counter += 1
+        param_name = f"param_{self._parameter_counter}"
+        self._parameters[param_name] = value
+        return self, param_name
 
     def _generate_unique_parameter_name(self, base_name: str) -> str:
         """Generate unique parameter name when collision occurs.
@@ -188,14 +201,58 @@ class QueryBuilder(ABC, Generic[RowT]):
         if base_name not in self._parameters:
             return base_name
 
-        i = 1
-        while True:
+        for i in range(1, 1000):  # Reasonable upper bound to prevent infinite loops
             name = f"{base_name}_{i}"
             if name not in self._parameters:
                 return name
-            i += 1
 
-    def with_cte(self: Self, alias: str, query: "Union[QueryBuilder[Any], exp.Select, str]") -> Self:
+        # Fallback for edge case
+        import uuid
+
+        return f"{base_name}_{uuid.uuid4().hex[:8]}"
+
+    def _generate_builder_cache_key(self, config: "Optional[StatementConfig]" = None) -> str:
+        """Generate cache key based on builder state and configuration.
+
+        Args:
+            config: Optional SQL configuration that affects the generated SQL
+
+        Returns:
+            A unique cache key representing the builder state and configuration
+        """
+        import hashlib
+
+        dialect_name: str = self.dialect_name or "default"
+        expr_sql: str = self._expression.sql() if self._expression else "None"
+
+        state_parts = [
+            f"expression:{expr_sql}",
+            f"parameters:{sorted(self._parameters.items())}",
+            f"ctes:{sorted(self._with_ctes.keys())}",
+            f"dialect:{dialect_name}",
+            f"schema:{self.schema}",
+            f"optimization:{self.enable_optimization}",
+            f"optimize_joins:{self.optimize_joins}",
+            f"optimize_predicates:{self.optimize_predicates}",
+            f"simplify_expressions:{self.simplify_expressions}",
+        ]
+
+        if config:
+            config_parts = [
+                f"config_dialect:{config.dialect or 'default'}",
+                f"enable_parsing:{config.enable_parsing}",
+                f"enable_validation:{config.enable_validation}",
+                f"enable_transformations:{config.enable_transformations}",
+                f"enable_analysis:{config.enable_analysis}",
+                f"enable_caching:{config.enable_caching}",
+                f"param_style:{config.parameter_config.default_parameter_style.value}",
+            ]
+            state_parts.extend(config_parts)
+
+        state_string = "|".join(state_parts)
+        return f"builder:{hashlib.sha256(state_string.encode()).hexdigest()[:16]}"
+
+    def with_cte(self: Self, alias: str, query: "Union[QueryBuilder, exp.Select, str]") -> Self:
         """Adds a Common Table Expression (CTE) to the query.
 
         Args:
@@ -217,9 +274,8 @@ class QueryBuilder(ABC, Generic[RowT]):
             if not isinstance(query._expression, exp.Select):
                 msg = f"CTE query builder expression must be a Select, got {type(query._expression).__name__}."
                 self._raise_sql_builder_error(msg)
-            cte_select_expression = query._expression.copy()
+            cte_select_expression = query._expression
             for p_name, p_value in query.parameters.items():
-                # Try to preserve original parameter name, only rename if collision
                 unique_name = self._generate_unique_parameter_name(p_name)
                 self.add_parameter(p_value, unique_name)
 
@@ -229,7 +285,6 @@ class QueryBuilder(ABC, Generic[RowT]):
                 if not isinstance(parsed_expression, exp.Select):
                     msg = f"CTE query string must parse to a SELECT statement, got {type(parsed_expression).__name__}."
                     self._raise_sql_builder_error(msg)
-                # parsed_expression is now known to be exp.Select
                 cte_select_expression = parsed_expression
             except SQLGlotParseError as e:
                 self._raise_sql_builder_error(f"Failed to parse CTE query string: {e!s}", e)
@@ -237,11 +292,11 @@ class QueryBuilder(ABC, Generic[RowT]):
                 msg = f"An unexpected error occurred while parsing CTE query string: {e!s}"
                 self._raise_sql_builder_error(msg, e)
         elif isinstance(query, exp.Select):
-            cte_select_expression = query.copy()
+            cte_select_expression = query
         else:
             msg = f"Invalid query type for CTE: {type(query).__name__}"
             self._raise_sql_builder_error(msg)
-            return self  # This line won't be reached but satisfies type checkers
+            return self
 
         self._with_ctes[alias] = exp.CTE(this=cte_select_expression, alias=exp.to_table(alias))
         return self
@@ -255,22 +310,22 @@ class QueryBuilder(ABC, Generic[RowT]):
         if self._expression is None:
             self._raise_sql_builder_error("QueryBuilder expression not initialized.")
 
-        final_expression = self._expression.copy()
-
         if self._with_ctes:
+            final_expression = self._expression
             if has_with_method(final_expression):
-                # Type checker now knows final_expression has with_ method
                 for alias, cte_node in self._with_ctes.items():
                     final_expression = cast("Any", final_expression).with_(cte_node.args["this"], as_=alias, copy=False)
             elif isinstance(final_expression, (exp.Select, exp.Insert, exp.Update, exp.Delete, exp.Union)):
                 final_expression = exp.With(expressions=list(self._with_ctes.values()), this=final_expression)
+        else:
+            final_expression = self._expression
 
         if self.enable_optimization and isinstance(final_expression, exp.Expression):
             final_expression = self._optimize_expression(final_expression)
 
         try:
             if has_sql_method(final_expression):
-                sql_string = final_expression.sql(dialect=self.dialect_name, pretty=True)  # pyright: ignore[reportAttributeAccessIssue]
+                sql_string = final_expression.sql(dialect=self.dialect_name, pretty=True)
             else:
                 sql_string = str(final_expression)
         except Exception as e:
@@ -281,7 +336,7 @@ class QueryBuilder(ABC, Generic[RowT]):
         return SafeQuery(sql=sql_string, parameters=self._parameters.copy(), dialect=self.dialect)
 
     def _optimize_expression(self, expression: exp.Expression) -> exp.Expression:
-        """Apply SQLGlot optimizations to the expression.
+        """Apply SQLGlot optimizations to the expression with caching.
 
         Args:
             expression: The expression to optimize
@@ -292,24 +347,63 @@ class QueryBuilder(ABC, Generic[RowT]):
         if not self.enable_optimization:
             return expression
 
+        optimizer_settings = {
+            "optimize_joins": self.optimize_joins,
+            "pushdown_predicates": self.optimize_predicates,
+            "simplify_expressions": self.simplify_expressions,
+        }
+
+        dialect_name = self.dialect_name or "default"
+        cache_key = hash_optimized_expression(
+            expression, dialect=dialect_name, schema=self.schema, optimizer_settings=optimizer_settings
+        )
+
+        cache_key_obj = CacheKey((cache_key,))
+        unified_cache = get_default_cache()
+        cached_optimized = unified_cache.get(cache_key_obj)
+        if cached_optimized:
+            return cast("exp.Expression", cached_optimized)
+
         try:
-            # Use SQLGlot's comprehensive optimizer
-            return optimize(
-                expression.copy(),
-                schema=self.schema,
-                dialect=self.dialect_name,
-                optimizer_settings={
-                    "optimize_joins": self.optimize_joins,
-                    "pushdown_predicates": self.optimize_predicates,
-                    "simplify_expressions": self.simplify_expressions,
-                },
+            optimized = optimize(
+                expression, schema=self.schema, dialect=self.dialect_name, optimizer_settings=optimizer_settings
             )
+
+            unified_cache.put(cache_key_obj, optimized)
+
         except Exception:
-            # Continue with unoptimized query on failure
             return expression
+        else:
+            return optimized
 
-    def to_statement(self, config: "Optional[SQLConfig]" = None) -> "SQL":
-        """Converts the built query into a SQL statement object.
+    def to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
+        """Converts the built query into a SQL statement object with caching.
+
+        Args:
+            config: Optional SQL configuration.
+
+        Returns:
+            SQL: A SQL statement object.
+        """
+        cache_config = get_cache_config()
+        if not cache_config.compiled_cache_enabled:
+            return self._to_statement_without_cache(config)
+
+        cache_key_str = self._generate_builder_cache_key(config)
+        cache_key = CacheKey((cache_key_str,))
+
+        unified_cache = get_default_cache()
+        cached_sql = unified_cache.get(cache_key)
+        if cached_sql is not None:
+            return cast("SQL", cached_sql)
+
+        sql_statement = self._to_statement_without_cache(config)
+        unified_cache.put(cache_key, sql_statement)
+
+        return sql_statement
+
+    def _to_statement_without_cache(self, config: "Optional[StatementConfig]" = None) -> "SQL":
+        """Internal method to create SQL statement without caching.
 
         Args:
             config: Optional SQL configuration.
@@ -321,7 +415,7 @@ class QueryBuilder(ABC, Generic[RowT]):
 
         if isinstance(safe_query.parameters, dict):
             kwargs = safe_query.parameters
-            parameters = None
+            parameters: Optional[tuple] = None
         else:
             kwargs = None
             parameters = (
@@ -333,16 +427,18 @@ class QueryBuilder(ABC, Generic[RowT]):
             )
 
         if config is None:
-            from sqlspec.statement.sql import SQLConfig
+            from sqlspec.core.statement import StatementConfig
 
-            config = SQLConfig(dialect=safe_query.dialect)
+            parameter_config = ParameterStyleConfig(
+                default_parameter_style=ParameterStyle.QMARK, supported_parameter_styles={ParameterStyle.QMARK}
+            )
+            config = StatementConfig(parameter_config=parameter_config, dialect=safe_query.dialect)
 
-        # SQL expects parameters as variadic args, not as a keyword
         if kwargs:
-            return SQL(safe_query.sql, config=config, **kwargs)
+            return SQL(safe_query.sql, statement_config=config, **kwargs)
         if parameters:
-            return SQL(safe_query.sql, *parameters, config=config)
-        return SQL(safe_query.sql, config=config)
+            return SQL(safe_query.sql, *parameters, statement_config=config)
+        return SQL(safe_query.sql, statement_config=config)
 
     def __str__(self) -> str:
         """Return the SQL string representation of the query.
@@ -365,8 +461,10 @@ class QueryBuilder(ABC, Generic[RowT]):
                 return self.dialect.__name__.lower()
             if isinstance(self.dialect, Dialect):
                 return type(self.dialect).__name__.lower()
-            if hasattr(self.dialect, "__name__"):
+            try:
                 return self.dialect.__name__.lower()
+            except AttributeError:
+                pass
         return None
 
     @property