diff --git a/pyproject.toml b/pyproject.toml
index ccba41be4..bcb10a188 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,7 +13,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.16.0"
+version = "0.16.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
diff --git a/sqlspec/_sql.py b/sqlspec/_sql.py
index c828e431b..9b1c63ee2 100644
--- a/sqlspec/_sql.py
+++ b/sqlspec/_sql.py
@@ -4,9 +4,10 @@
 """
 
 import logging
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 import sqlglot
+from mypy_extensions import trait
 from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 from sqlglot.errors import ParseError as SQLGlotParseError
@@ -36,6 +37,7 @@
 from sqlspec.exceptions import SQLBuilderError
 
 if TYPE_CHECKING:
+    from sqlspec.builder._column import ColumnExpression
     from sqlspec.core.statement import SQL
 
 __all__ = (
@@ -61,6 +63,7 @@
     "Select",
     "Truncate",
     "Update",
+    "WindowFunctionBuilder",
     "sql",
 )
 
@@ -188,12 +191,8 @@ def select(self, *columns_or_sql: Union[str, exp.Expression, Column], dialect: D
                     )
                     raise SQLBuilderError(msg)
                 select_builder = Select(dialect=builder_dialect)
-                if select_builder._expression is None:
-                    select_builder.__post_init__()
                 return self._populate_select_from_sql(select_builder, sql_candidate)
         select_builder = Select(dialect=builder_dialect)
-        if select_builder._expression is None:
-            select_builder.__post_init__()
         if columns_or_sql:
             select_builder.select(*columns_or_sql)
         return select_builder
@@ -201,8 +200,6 @@ def select(self, *columns_or_sql: Union[str, exp.Expression, Column], dialect: D
     def insert(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Insert":
         builder_dialect = dialect or self.dialect
         builder = Insert(dialect=builder_dialect)
-        if builder._expression is None:
-            builder.__post_init__()
         if table_or_sql:
             if self._looks_like_sql(table_or_sql):
                 detected = self.detect_sql_type(table_or_sql, dialect=builder_dialect)
@@ -220,8 +217,6 @@ def insert(self, table_or_sql: Optional[str] = None, dialect: DialectType = None
     def update(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Update":
         builder_dialect = dialect or self.dialect
         builder = Update(dialect=builder_dialect)
-        if builder._expression is None:
-            builder.__post_init__()
         if table_or_sql:
             if self._looks_like_sql(table_or_sql):
                 detected = self.detect_sql_type(table_or_sql, dialect=builder_dialect)
@@ -235,8 +230,6 @@ def update(self, table_or_sql: Optional[str] = None, dialect: DialectType = None
     def delete(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Delete":
         builder_dialect = dialect or self.dialect
         builder = Delete(dialect=builder_dialect)
-        if builder._expression is None:
-            builder.__post_init__()
         if table_or_sql and self._looks_like_sql(table_or_sql):
             detected = self.detect_sql_type(table_or_sql, dialect=builder_dialect)
             if detected != "DELETE":
@@ -248,8 +241,6 @@ def delete(self, table_or_sql: Optional[str] = None, dialect: DialectType = None
     def merge(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Merge":
         builder_dialect = dialect or self.dialect
         builder = Merge(dialect=builder_dialect)
-        if builder._expression is None:
-            builder.__post_init__()
         if table_or_sql:
             if self._looks_like_sql(table_or_sql):
                 detected = self.detect_sql_type(table_or_sql, dialect=builder_dialect)
@@ -563,14 +554,112 @@ def column(self, name: str, table: Optional[str] = None) -> Column:
         """
         return Column(name, table)
 
-    def __getattr__(self, name: str) -> Column:
+    @property
+    def case_(self) -> "Case":
+        """Create a CASE expression builder with improved syntax.
+
+        Returns:
+            Case builder instance for fluent CASE expression building.
+
+        Example:
+            ```python
+            case_expr = (
+                sql.case_.when("x = 1", "one")
+                .when("x = 2", "two")
+                .else_("other")
+                .end()
+            )
+            aliased_case = (
+                sql.case_.when("status = 'active'", 1)
+                .else_(0)
+                .as_("is_active")
+            )
+            ```
+        """
+        return Case()
+
+    @property
+    def row_number_(self) -> "WindowFunctionBuilder":
+        """Create a ROW_NUMBER() window function builder."""
+        return WindowFunctionBuilder("row_number")
+
+    @property
+    def rank_(self) -> "WindowFunctionBuilder":
+        """Create a RANK() window function builder."""
+        return WindowFunctionBuilder("rank")
+
+    @property
+    def dense_rank_(self) -> "WindowFunctionBuilder":
+        """Create a DENSE_RANK() window function builder."""
+        return WindowFunctionBuilder("dense_rank")
+
+    @property
+    def lag_(self) -> "WindowFunctionBuilder":
+        """Create a LAG() window function builder."""
+        return WindowFunctionBuilder("lag")
+
+    @property
+    def lead_(self) -> "WindowFunctionBuilder":
+        """Create a LEAD() window function builder."""
+        return WindowFunctionBuilder("lead")
+
+    @property
+    def exists_(self) -> "SubqueryBuilder":
+        """Create an EXISTS subquery builder."""
+        return SubqueryBuilder("exists")
+
+    @property
+    def in_(self) -> "SubqueryBuilder":
+        """Create an IN subquery builder."""
+        return SubqueryBuilder("in")
+
+    @property
+    def any_(self) -> "SubqueryBuilder":
+        """Create an ANY subquery builder."""
+        return SubqueryBuilder("any")
+
+    @property
+    def all_(self) -> "SubqueryBuilder":
+        """Create an ALL subquery builder."""
+        return SubqueryBuilder("all")
+
+    @property
+    def inner_join_(self) -> "JoinBuilder":
+        """Create an INNER JOIN builder."""
+        return JoinBuilder("inner join")
+
+    @property
+    def left_join_(self) -> "JoinBuilder":
+        """Create a LEFT JOIN builder."""
+        return JoinBuilder("left join")
+
+    @property
+    def right_join_(self) -> "JoinBuilder":
+        """Create a RIGHT JOIN builder."""
+        return JoinBuilder("right join")
+
+    @property
+    def full_join_(self) -> "JoinBuilder":
+        """Create a FULL OUTER JOIN builder."""
+        return JoinBuilder("full join")
+
+    @property
+    def cross_join_(self) -> "JoinBuilder":
+        """Create a CROSS JOIN builder."""
+        return JoinBuilder("cross join")
+
+    def __getattr__(self, name: str) -> "Column":
         """Dynamically create column references.
 
         Args:
             name: Column name.
 
         Returns:
-            Column object that supports method chaining and operator overloading.
+            Column object for the given name.
+
+        Note:
+            Special SQL constructs like case_, row_number_, etc. are now
+            handled as properties for better type safety.
         """
         return Column(name)
 
@@ -1282,6 +1371,7 @@ def _create_window_function(
         return exp.Window(this=func_expr, **over_args)
 
 
+@trait
 class Case:
     """Builder for CASE expressions using the SQL factory.
 
@@ -1304,6 +1394,19 @@ def __init__(self) -> None:
         self._conditions: list[exp.If] = []
         self._default: Optional[exp.Expression] = None
 
+    def __eq__(self, other: object) -> "ColumnExpression":  # type: ignore[override]
+        """Equal to (==) - convert to expression then compare."""
+        from sqlspec.builder._column import ColumnExpression
+
+        case_expr = exp.Case(ifs=self._conditions, default=self._default)
+        if other is None:
+            return ColumnExpression(exp.Is(this=case_expr, expression=exp.Null()))
+        return ColumnExpression(exp.EQ(this=case_expr, expression=exp.convert(other)))
+
+    def __hash__(self) -> int:
+        """Make Case hashable."""
+        return hash(id(self))
+
     def when(self, condition: Union[str, exp.Expression], value: Union[str, exp.Expression, Any]) -> "Case":
         """Add a WHEN clause.
 
@@ -1342,6 +1445,336 @@ def end(self) -> exp.Expression:
         """
         return exp.Case(ifs=self._conditions, default=self._default)
 
+    def as_(self, alias: str) -> exp.Alias:
+        """Complete the CASE expression with an alias.
+
+        Args:
+            alias: Alias name for the CASE expression.
+
+        Returns:
+            Aliased CASE expression.
+        """
+        case_expr = exp.Case(ifs=self._conditions, default=self._default)
+        return cast("exp.Alias", exp.alias_(case_expr, alias))
+
+
+@trait
+class WindowFunctionBuilder:
+    """Builder for window functions with fluent syntax.
+
+    Example:
+        ```python
+        from sqlspec import sql
+
+        # sql.row_number_.partition_by("department").order_by("salary")
+        window_func = (
+            sql.row_number_.partition_by("department")
+            .order_by("salary")
+            .as_("row_num")
+        )
+        ```
+    """
+
+    def __init__(self, function_name: str) -> None:
+        """Initialize the window function builder.
+
+        Args:
+            function_name: Name of the window function (row_number, rank, etc.)
+        """
+        self._function_name = function_name
+        self._partition_by_cols: list[exp.Expression] = []
+        self._order_by_cols: list[exp.Expression] = []
+        self._alias: Optional[str] = None
+
+    def __eq__(self, other: object) -> "ColumnExpression":  # type: ignore[override]
+        """Equal to (==) - convert to expression then compare."""
+        from sqlspec.builder._column import ColumnExpression
+
+        window_expr = self._build_expression()
+        if other is None:
+            return ColumnExpression(exp.Is(this=window_expr, expression=exp.Null()))
+        return ColumnExpression(exp.EQ(this=window_expr, expression=exp.convert(other)))
+
+    def __hash__(self) -> int:
+        """Make WindowFunctionBuilder hashable."""
+        return hash(id(self))
+
+    def partition_by(self, *columns: Union[str, exp.Expression]) -> "WindowFunctionBuilder":
+        """Add PARTITION BY clause.
+
+        Args:
+            *columns: Columns to partition by.
+
+        Returns:
+            Self for method chaining.
+        """
+        for col in columns:
+            col_expr = exp.column(col) if isinstance(col, str) else col
+            self._partition_by_cols.append(col_expr)
+        return self
+
+    def order_by(self, *columns: Union[str, exp.Expression]) -> "WindowFunctionBuilder":
+        """Add ORDER BY clause.
+
+        Args:
+            *columns: Columns to order by.
+
+        Returns:
+            Self for method chaining.
+        """
+        for col in columns:
+            if isinstance(col, str):
+                col_expr = exp.column(col).asc()
+                self._order_by_cols.append(col_expr)
+            else:
+                # Convert to ordered expression
+                self._order_by_cols.append(exp.Ordered(this=col, desc=False))
+        return self
+
+    def as_(self, alias: str) -> exp.Expression:
+        """Complete the window function with an alias.
+
+        Args:
+            alias: Alias name for the window function.
+
+        Returns:
+            Aliased window function expression.
+        """
+        window_expr = self._build_expression()
+        return cast("exp.Alias", exp.alias_(window_expr, alias))
+
+    def build(self) -> exp.Expression:
+        """Complete the window function without an alias.
+
+        Returns:
+            Window function expression.
+        """
+        return self._build_expression()
+
+    def _build_expression(self) -> exp.Expression:
+        """Build the complete window function expression."""
+        # Create the function expression
+        func_expr = exp.Anonymous(this=self._function_name.upper(), expressions=[])
+
+        # Build the OVER clause arguments
+        over_args: dict[str, Any] = {}
+
+        if self._partition_by_cols:
+            over_args["partition_by"] = self._partition_by_cols
+
+        if self._order_by_cols:
+            over_args["order"] = exp.Order(expressions=self._order_by_cols)
+
+        return exp.Window(this=func_expr, **over_args)
+
+
+@trait
+class SubqueryBuilder:
+    """Builder for subquery operations with fluent syntax.
+
+    Example:
+        ```python
+        from sqlspec import sql
+
+        # sql.exists_(subquery)
+        exists_check = sql.exists_(
+            sql.select("1")
+            .from_("orders")
+            .where_eq("user_id", sql.users.id)
+        )
+
+        # sql.in_(subquery)
+        in_check = sql.in_(
+            sql.select("category_id")
+            .from_("categories")
+            .where_eq("active", True)
+        )
+        ```
+    """
+
+    def __init__(self, operation: str) -> None:
+        """Initialize the subquery builder.
+
+        Args:
+            operation: Type of subquery operation (exists, in, any, all)
+        """
+        self._operation = operation
+
+    def __eq__(self, other: object) -> "ColumnExpression":  # type: ignore[override]
+        """Equal to (==) - not typically used but needed for type consistency."""
+        from sqlspec.builder._column import ColumnExpression
+
+        # SubqueryBuilder doesn't have a direct expression, so this is a placeholder
+        # In practice, this shouldn't be called as subqueries are used differently
+        placeholder_expr = exp.Literal.string(f"subquery_{self._operation}")
+        if other is None:
+            return ColumnExpression(exp.Is(this=placeholder_expr, expression=exp.Null()))
+        return ColumnExpression(exp.EQ(this=placeholder_expr, expression=exp.convert(other)))
+
+    def __hash__(self) -> int:
+        """Make SubqueryBuilder hashable."""
+        return hash(id(self))
+
+    def __call__(self, subquery: Union[str, exp.Expression, Any]) -> exp.Expression:
+        """Build the subquery expression.
+
+        Args:
+            subquery: The subquery - can be a SQL string, SelectBuilder, or expression
+
+        Returns:
+            The subquery expression (EXISTS, IN, ANY, ALL, etc.)
+        """
+        subquery_expr: exp.Expression
+        if isinstance(subquery, str):
+            # Parse as SQL
+            parsed: Optional[exp.Expression] = exp.maybe_parse(subquery)
+            if not parsed:
+                msg = f"Could not parse subquery SQL: {subquery}"
+                raise SQLBuilderError(msg)
+            subquery_expr = parsed
+        elif hasattr(subquery, "build") and callable(getattr(subquery, "build", None)):
+            # It's a query builder - build it to get the SQL and parse
+            built_query = subquery.build()  # pyright: ignore[reportAttributeAccessIssue]
+            subquery_expr = exp.maybe_parse(built_query.sql)
+            if not subquery_expr:
+                msg = f"Could not parse built query: {built_query.sql}"
+                raise SQLBuilderError(msg)
+        elif isinstance(subquery, exp.Expression):
+            subquery_expr = subquery
+        else:
+            # Try to convert to expression
+            parsed = exp.maybe_parse(str(subquery))
+            if not parsed:
+                msg = f"Could not convert subquery to expression: {subquery}"
+                raise SQLBuilderError(msg)
+            subquery_expr = parsed
+
+        # Build the appropriate expression based on operation
+        if self._operation == "exists":
+            return exp.Exists(this=subquery_expr)
+        if self._operation == "in":
+            # For IN, we create a subquery that can be used with WHERE column IN (subquery)
+            return exp.In(expressions=[subquery_expr])
+        if self._operation == "any":
+            return exp.Any(this=subquery_expr)
+        if self._operation == "all":
+            return exp.All(this=subquery_expr)
+        msg = f"Unknown subquery operation: {self._operation}"
+        raise SQLBuilderError(msg)
+
+
+@trait
+class JoinBuilder:
+    """Builder for JOIN operations with fluent syntax.
+
+    Example:
+        ```python
+        from sqlspec import sql
+
+        # sql.left_join_("posts").on("users.id = posts.user_id")
+        join_clause = sql.left_join_("posts").on(
+            "users.id = posts.user_id"
+        )
+
+        # Or with query builder
+        query = (
+            sql.select("users.name", "posts.title")
+            .from_("users")
+            .join(
+                sql.left_join_("posts").on(
+                    "users.id = posts.user_id"
+                )
+            )
+        )
+        ```
+    """
+
+    def __init__(self, join_type: str) -> None:
+        """Initialize the join builder.
+
+        Args:
+            join_type: Type of join (inner, left, right, full, cross)
+        """
+        self._join_type = join_type.upper()
+        self._table: Optional[Union[str, exp.Expression]] = None
+        self._condition: Optional[exp.Expression] = None
+        self._alias: Optional[str] = None
+
+    def __eq__(self, other: object) -> "ColumnExpression":  # type: ignore[override]
+        """Equal to (==) - not typically used but needed for type consistency."""
+        from sqlspec.builder._column import ColumnExpression
+
+        # JoinBuilder doesn't have a direct expression, so this is a placeholder
+        # In practice, this shouldn't be called as joins are used differently
+        placeholder_expr = exp.Literal.string(f"join_{self._join_type.lower()}")
+        if other is None:
+            return ColumnExpression(exp.Is(this=placeholder_expr, expression=exp.Null()))
+        return ColumnExpression(exp.EQ(this=placeholder_expr, expression=exp.convert(other)))
+
+    def __hash__(self) -> int:
+        """Make JoinBuilder hashable."""
+        return hash(id(self))
+
+    def __call__(self, table: Union[str, exp.Expression], alias: Optional[str] = None) -> "JoinBuilder":
+        """Set the table to join.
+
+        Args:
+            table: Table name or expression to join
+            alias: Optional alias for the table
+
+        Returns:
+            Self for method chaining
+        """
+        self._table = table
+        self._alias = alias
+        return self
+
+    def on(self, condition: Union[str, exp.Expression]) -> exp.Expression:
+        """Set the join condition and build the JOIN expression.
+
+        Args:
+            condition: JOIN condition (e.g., "users.id = posts.user_id")
+
+        Returns:
+            Complete JOIN expression
+        """
+        if not self._table:
+            msg = "Table must be set before calling .on()"
+            raise SQLBuilderError(msg)
+
+        # Parse the condition
+        condition_expr: exp.Expression
+        if isinstance(condition, str):
+            parsed: Optional[exp.Expression] = exp.maybe_parse(condition)
+            condition_expr = parsed or exp.condition(condition)
+        else:
+            condition_expr = condition
+
+        # Build table expression
+        table_expr: exp.Expression
+        if isinstance(self._table, str):
+            table_expr = exp.to_table(self._table)
+            if self._alias:
+                table_expr = cast("exp.Expression", exp.alias_(table_expr, self._alias))
+        else:
+            table_expr = self._table
+            if self._alias:
+                table_expr = cast("exp.Expression", exp.alias_(table_expr, self._alias))
+
+        # Create the appropriate join type using same pattern as existing JoinClauseMixin
+        if self._join_type == "INNER JOIN":
+            return exp.Join(this=table_expr, on=condition_expr)
+        if self._join_type == "LEFT JOIN":
+            return exp.Join(this=table_expr, on=condition_expr, side="LEFT")
+        if self._join_type == "RIGHT JOIN":
+            return exp.Join(this=table_expr, on=condition_expr, side="RIGHT")
+        if self._join_type == "FULL JOIN":
+            return exp.Join(this=table_expr, on=condition_expr, side="FULL", kind="OUTER")
+        if self._join_type == "CROSS JOIN":
+            # CROSS JOIN doesn't use ON condition
+            return exp.Join(this=table_expr, kind="CROSS")
+        return exp.Join(this=table_expr, on=condition_expr)
+
 
 # Create a default SQL factory instance
 sql = SQLFactory()
diff --git a/sqlspec/builder/_base.py b/sqlspec/builder/_base.py
index 28ea6529c..161265be8 100644
--- a/sqlspec/builder/_base.py
+++ b/sqlspec/builder/_base.py
@@ -5,7 +5,6 @@
 """
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, NoReturn, Optional, Union, cast
 
 import sqlglot
@@ -31,16 +30,19 @@
 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):
     """Abstract base class for SQL query builders with SQLGlot optimization.
 
@@ -48,18 +50,43 @@ class QueryBuilder(ABC):
     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:
             self._raise_sql_builder_error(
@@ -135,7 +162,7 @@ def replacer(node: exp.Expression) -> exp.Expression:
                 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.
@@ -154,13 +181,13 @@ def add_parameter(self: Self, value: Any, name: Optional[str] = None) -> tuple[S
         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.
@@ -174,12 +201,15 @@ def _generate_unique_parameter_name(self, base_name: str) -> str:
         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
+
+        # 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.
@@ -192,11 +222,14 @@ def _generate_builder_cache_key(self, config: "Optional[StatementConfig]" = None
         """
         import hashlib
 
-        state_components = [
-            f"expression:{self._expression.sql() if self._expression else 'None'}",
+        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:{self.dialect_name or 'default'}",
+            f"dialect:{dialect_name}",
             f"schema:{self.schema}",
             f"optimization:{self.enable_optimization}",
             f"optimize_joins:{self.optimize_joins}",
@@ -205,7 +238,7 @@ def _generate_builder_cache_key(self, config: "Optional[StatementConfig]" = None
         ]
 
         if config:
-            config_components = [
+            config_parts = [
                 f"config_dialect:{config.dialect or 'default'}",
                 f"enable_parsing:{config.enable_parsing}",
                 f"enable_validation:{config.enable_validation}",
@@ -214,12 +247,10 @@ def _generate_builder_cache_key(self, config: "Optional[StatementConfig]" = None
                 f"enable_caching:{config.enable_caching}",
                 f"param_style:{config.parameter_config.default_parameter_style.value}",
             ]
-            state_components.extend(config_components)
+            state_parts.extend(config_parts)
 
-        state_string = "|".join(state_components)
-        cache_key = hashlib.sha256(state_string.encode()).hexdigest()[:16]
-
-        return f"builder:{cache_key}"
+        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.
@@ -243,7 +274,7 @@ def with_cte(self: Self, alias: str, query: "Union[QueryBuilder, exp.Select, str
             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():
                 unique_name = self._generate_unique_parameter_name(p_name)
                 self.add_parameter(p_value, unique_name)
@@ -261,7 +292,7 @@ def with_cte(self: Self, alias: str, query: "Union[QueryBuilder, exp.Select, str
                 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)
@@ -280,14 +311,14 @@ def build(self) -> "SafeQuery":
             self._raise_sql_builder_error("QueryBuilder expression not initialized.")
 
         if self._with_ctes:
-            final_expression = self._expression.copy()
+            final_expression = self._expression
             if has_with_method(final_expression):
                 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.copy() if self.enable_optimization else self._expression
+            final_expression = self._expression
 
         if self.enable_optimization and isinstance(final_expression, exp.Expression):
             final_expression = self._optimize_expression(final_expression)
@@ -335,10 +366,10 @@ def _optimize_expression(self, expression: exp.Expression) -> exp.Expression:
 
         try:
             optimized = optimize(
-                expression.copy(), schema=self.schema, dialect=self.dialect_name, optimizer_settings=optimizer_settings
+                expression, schema=self.schema, dialect=self.dialect_name, optimizer_settings=optimizer_settings
             )
 
-            unified_cache.put(cache_key_obj, optimized.copy())
+            unified_cache.put(cache_key_obj, optimized)
 
         except Exception:
             return expression
@@ -430,8 +461,10 @@ def dialect_name(self) -> "Optional[str]":
                 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
diff --git a/sqlspec/builder/_column.py b/sqlspec/builder/_column.py
index b43bae3b3..3b399d116 100644
--- a/sqlspec/builder/_column.py
+++ b/sqlspec/builder/_column.py
@@ -67,7 +67,6 @@ def __init__(self, name: str, table: Optional[str] = None) -> None:
         else:
             self._expression = exp.Column(this=exp.Identifier(this=name))
 
-    # Comparison operators
     def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
         """Equal to (==)."""
         if other is None:
@@ -100,7 +99,6 @@ def __invert__(self) -> ColumnExpression:
         """Apply NOT operator (~)."""
         return ColumnExpression(exp.Not(this=self._expression))
 
-    # SQL-specific methods
     def like(self, pattern: str, escape: Optional[str] = None) -> ColumnExpression:
         """SQL LIKE pattern matching."""
         if escape:
@@ -152,7 +150,6 @@ def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
         converted_values = [exp.convert(v) for v in values]
         return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
-    # SQL Functions
     def lower(self) -> "FunctionColumn":
         """SQL LOWER() function."""
         return FunctionColumn(exp.Lower(this=self._expression))
@@ -203,7 +200,6 @@ def cast(self, data_type: str) -> "FunctionColumn":
         """SQL CAST() function."""
         return FunctionColumn(exp.Cast(this=self._expression, to=exp.DataType.build(data_type)))
 
-    # Aggregate functions
     def count(self) -> "FunctionColumn":
         """SQL COUNT() function."""
         return FunctionColumn(exp.Count(this=self._expression))
diff --git a/sqlspec/builder/_ddl.py b/sqlspec/builder/_ddl.py
index 3221aa993..68749b822 100644
--- a/sqlspec/builder/_ddl.py
+++ b/sqlspec/builder/_ddl.py
@@ -45,7 +45,8 @@ class DDLBuilder(QueryBuilder):
     _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
 
     def __post_init__(self) -> None:
-        pass
+        # Initialize parent class attributes since dataclass doesn't call super().__init__()
+        super().__init__(dialect=self.dialect)
 
     def _create_base_expression(self) -> exp.Expression:
         msg = "Subclasses must implement _create_base_expression."
@@ -64,7 +65,6 @@ def to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
         return super().to_statement(config=config)
 
 
-# --- Data Structures for CREATE TABLE ---
 @dataclass
 class ColumnDefinition:
     """Column definition for CREATE TABLE."""
@@ -78,7 +78,7 @@ class ColumnDefinition:
     auto_increment: bool = False
     comment: "Optional[str]" = None
     check: "Optional[str]" = None
-    generated: "Optional[str]" = None  # For computed columns
+    generated: "Optional[str]" = None
     collate: "Optional[str]" = None
 
 
@@ -86,7 +86,7 @@ class ColumnDefinition:
 class ConstraintDefinition:
     """Constraint definition for CREATE TABLE."""
 
-    constraint_type: str  # 'PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK'
+    constraint_type: str
     name: "Optional[str]" = None
     columns: "list[str]" = field(default_factory=list)
     references_table: "Optional[str]" = None
@@ -98,7 +98,6 @@ class ConstraintDefinition:
     initially_deferred: bool = False
 
 
-# --- CREATE TABLE ---
 @dataclass
 class CreateTable(DDLBuilder):
     """Builder for CREATE TABLE statements with columns and constraints.
@@ -199,7 +198,6 @@ def column(
 
         self._columns.append(column_def)
 
-        # If primary key is specified on column, also add a constraint
         if primary_key and not any(c.constraint_type == "PRIMARY KEY" for c in self._constraints):
             self.primary_key_constraint([name])
 
@@ -235,12 +233,10 @@ def foreign_key_constraint(
         initially_deferred: bool = False,
     ) -> "Self":
         """Add a foreign key constraint."""
-        # Normalize inputs
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         ref_col_list = [references_columns] if isinstance(references_columns, str) else list(references_columns)
 
-        # Validation
         if len(col_list) != len(ref_col_list):
             self._raise_sql_builder_error("Foreign key columns and referenced columns must have same length")
 
@@ -267,7 +263,6 @@ def foreign_key_constraint(
 
     def unique_constraint(self, columns: "Union[str, list[str]]", name: "Optional[str]" = None) -> "Self":
         """Add a unique constraint."""
-        # Normalize column list
         col_list = [columns] if isinstance(columns, str) else list(columns)
 
         if not col_list:
@@ -285,11 +280,9 @@ def check_constraint(self, condition: Union[str, "ColumnExpression"], name: "Opt
 
         condition_str: str
         if hasattr(condition, "sqlglot_expression"):
-            # This is a ColumnExpression - render as raw SQL for DDL (no parameters)
             sqlglot_expr = getattr(condition, "sqlglot_expression", None)
             condition_str = sqlglot_expr.sql(dialect=self.dialect) if sqlglot_expr else str(condition)
         else:
-            # String condition - use as-is
             condition_str = str(condition)
 
         constraint = ConstraintDefinition(constraint_type="CHECK", name=name, condition=condition_str)
@@ -338,7 +331,6 @@ def _create_base_expression(self) -> "exp.Expression":
             column_defs.append(col_expr)
 
         for constraint in self._constraints:
-            # Skip PRIMARY KEY constraints that are already defined on columns
             if constraint.constraint_type == "PRIMARY KEY" and len(constraint.columns) == 1:
                 col_name = constraint.columns[0]
                 if any(c.name == col_name and c.primary_key for c in self._columns):
@@ -361,7 +353,7 @@ def _create_base_expression(self) -> "exp.Expression":
             props.append(exp.Property(this=exp.to_identifier("PARTITION BY"), value=exp.convert(self._partition_by)))
 
         for key, value in self._table_options.items():
-            if key != "engine":  # Skip already handled options
+            if key != "engine":
                 props.append(exp.Property(this=exp.to_identifier(key.upper()), value=exp.convert(value)))
 
         properties_node = exp.Properties(expressions=props) if props else None
@@ -393,14 +385,13 @@ def _build_constraint_expression(constraint: "ConstraintDefinition") -> "Optiona
         return build_constraint_expression(constraint)
 
 
-# --- DROP TABLE ---
 @dataclass
 class DropTable(DDLBuilder):
     """Builder for DROP TABLE [IF EXISTS] ... [CASCADE|RESTRICT]."""
 
     _table_name: Optional[str] = None
     _if_exists: bool = False
-    _cascade: Optional[bool] = None  # True: CASCADE, False: RESTRICT, None: not set
+    _cascade: Optional[bool] = None
 
     def __init__(self, table_name: str, **kwargs: Any) -> None:
         """Initialize DROP TABLE with table name.
@@ -436,7 +427,6 @@ def _create_base_expression(self) -> exp.Expression:
         )
 
 
-# --- DROP INDEX ---
 @dataclass
 class DropIndex(DDLBuilder):
     """Builder for DROP INDEX [IF EXISTS] ... [ON table] [CASCADE|RESTRICT]."""
@@ -488,7 +478,6 @@ def _create_base_expression(self) -> exp.Expression:
         )
 
 
-# --- DROP VIEW ---
 @dataclass
 class DropView(DDLBuilder):
     """Builder for DROP VIEW [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -521,7 +510,6 @@ def _create_base_expression(self) -> exp.Expression:
         )
 
 
-# --- DROP SCHEMA ---
 @dataclass
 class DropSchema(DDLBuilder):
     """Builder for DROP SCHEMA [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -554,7 +542,6 @@ def _create_base_expression(self) -> exp.Expression:
         )
 
 
-# --- CREATE INDEX ---
 @dataclass
 class CreateIndex(DDLBuilder):
     """Builder for CREATE [UNIQUE] INDEX [IF NOT EXISTS] ... ON ... (...).
@@ -579,7 +566,6 @@ def __init__(self, index_name: str, **kwargs: Any) -> None:
         """
         super().__init__(**kwargs)
         self._index_name = index_name
-        # Initialize dataclass fields that may not be set by super().__init__
         if not hasattr(self, "_columns"):
             self._columns = []
 
@@ -627,7 +613,6 @@ def _create_base_expression(self) -> exp.Expression:
         where_expr = None
         if self._where:
             where_expr = exp.condition(self._where) if isinstance(self._where, str) else self._where
-        # Use exp.Create for CREATE INDEX
         return exp.Create(
             kind="INDEX",
             this=exp.to_identifier(self._index_name),
@@ -640,14 +625,13 @@ def _create_base_expression(self) -> exp.Expression:
         )
 
 
-# --- TRUNCATE TABLE ---
 @dataclass
 class Truncate(DDLBuilder):
     """Builder for TRUNCATE TABLE ... [CASCADE|RESTRICT] [RESTART IDENTITY|CONTINUE IDENTITY]."""
 
     _table_name: Optional[str] = None
     _cascade: Optional[bool] = None
-    _identity: Optional[str] = None  # "RESTART" or "CONTINUE"
+    _identity: Optional[str] = None
 
     def table(self, name: str) -> Self:
         self._table_name = name
@@ -676,7 +660,6 @@ def _create_base_expression(self) -> exp.Expression:
         return exp.TruncateTable(this=exp.to_table(self._table_name), cascade=self._cascade, identity=identity_expr)
 
 
-# --- ALTER TABLE ---
 @dataclass
 class AlterOperation:
     """Represents a single ALTER TABLE operation."""
@@ -693,7 +676,6 @@ class AlterOperation:
     using_expression: "Optional[str]" = None
 
 
-# --- CREATE SCHEMA ---
 @dataclass
 class CreateSchema(DDLBuilder):
     """Builder for CREATE SCHEMA [IF NOT EXISTS] schema_name [AUTHORIZATION user_name]."""
@@ -757,7 +739,7 @@ class CreateTableAsSelect(DDLBuilder):
     _table_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
+    _select_query: Optional[object] = None
 
     def name(self, table_name: str) -> Self:
         self._table_name = table_name
@@ -797,11 +779,7 @@ def _create_base_expression(self) -> exp.Expression:
             if with_ctes and select_expr and isinstance(select_expr, exp.Select):
                 for alias, cte in with_ctes.items():
                     if hasattr(select_expr, "with_"):
-                        select_expr = select_expr.with_(
-                            cte.this,  # The CTE's SELECT expression
-                            as_=alias,
-                            copy=False,
-                        )
+                        select_expr = select_expr.with_(cte.this, as_=alias, copy=False)
         elif isinstance(self._select_query, str):
             select_expr = exp.maybe_parse(self._select_query)
             select_parameters = None
@@ -810,11 +788,8 @@ def _create_base_expression(self) -> exp.Expression:
         if select_expr is None:
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -840,8 +815,8 @@ class CreateMaterializedView(DDLBuilder):
     _view_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
-    _with_data: Optional[bool] = None  # True: WITH DATA, False: NO DATA, None: not set
+    _select_query: Optional[object] = None
+    _with_data: Optional[bool] = None
     _refresh_mode: Optional[str] = None
     _storage_parameters: dict[str, Any] = field(default_factory=dict)
     _tablespace: Optional[str] = None
@@ -917,11 +892,8 @@ def _create_base_expression(self) -> exp.Expression:
         if select_expr is None or not isinstance(select_expr, exp.Select):
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -964,7 +936,7 @@ class CreateView(DDLBuilder):
     _view_name: Optional[str] = None
     _if_not_exists: bool = False
     _columns: list[str] = field(default_factory=list)
-    _select_query: Optional[object] = None  # SQL, SelectBuilder, or str
+    _select_query: Optional[object] = None
     _hints: list[str] = field(default_factory=list)
 
     def name(self, view_name: str) -> Self:
@@ -1012,11 +984,8 @@ def _create_base_expression(self) -> exp.Expression:
         if select_expr is None or not isinstance(select_expr, exp.Select):
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
-        # Merge parameters from SELECT if present
         if select_parameters:
             for p_name, p_value in select_parameters.items():
-                # Always preserve the original parameter name
-                # The SELECT query already has unique parameter names
                 self._parameters[p_name] = p_value
 
         schema_expr = None
@@ -1164,17 +1133,14 @@ def add_constraint(
         if constraint_type.upper() not in valid_types:
             self._raise_sql_builder_error(f"Invalid constraint type: {constraint_type}")
 
-        # Normalize columns
         col_list = None
         if columns is not None:
             col_list = [columns] if isinstance(columns, str) else list(columns)
 
-        # Normalize reference columns
         ref_col_list = None
         if references_columns is not None:
             ref_col_list = [references_columns] if isinstance(references_columns, str) else list(references_columns)
 
-        # Handle ColumnExpression for CHECK constraints
         condition_str: Optional[str] = None
         if condition is not None:
             if hasattr(condition, "sqlglot_expression"):
@@ -1246,9 +1212,6 @@ def _build_operation_expression(self, op: "AlterOperation") -> exp.Expression:
         if op_type == "ADD COLUMN":
             if not op.column_definition:
                 self._raise_sql_builder_error("Column definition required for ADD COLUMN")
-            # SQLGlot expects a ColumnDef directly for ADD COLUMN actions
-            # Note: SQLGlot doesn't support AFTER/FIRST positioning in standard ALTER TABLE ADD COLUMN
-            # These would need to be handled at the dialect level
             return build_column_expression(op.column_definition)
 
         if op_type == "DROP COLUMN":
@@ -1311,7 +1274,7 @@ def _build_operation_expression(self, op: "AlterOperation") -> exp.Expression:
             return exp.AlterColumn(this=exp.to_identifier(op.column_name), kind="DROP DEFAULT")
 
         self._raise_sql_builder_error(f"Unknown operation type: {op.operation_type}")
-        raise AssertionError  # This line is unreachable but satisfies the linter
+        raise AssertionError
 
 
 @dataclass
@@ -1321,7 +1284,7 @@ class CommentOn(DDLBuilder):
     Supports COMMENT ON TABLE and COMMENT ON COLUMN.
     """
 
-    _target_type: Optional[str] = None  # 'TABLE' or 'COLUMN'
+    _target_type: Optional[str] = None
     _table: Optional[str] = None
     _column: Optional[str] = None
     _comment: Optional[str] = None
@@ -1352,7 +1315,7 @@ def _create_base_expression(self) -> exp.Expression:
                 expression=exp.convert(self._comment),
             )
         self._raise_sql_builder_error("Must specify target and comment for COMMENT ON statement.")
-        raise AssertionError  # This line is unreachable but satisfies the linter
+        raise AssertionError
 
 
 @dataclass
diff --git a/sqlspec/builder/_ddl_utils.py b/sqlspec/builder/_ddl_utils.py
index e6dabd910..e8aa961ed 100644
--- a/sqlspec/builder/_ddl_utils.py
+++ b/sqlspec/builder/_ddl_utils.py
@@ -33,7 +33,6 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
             else:
                 default_expr = exp.convert(col.default)
         else:
-            # Use exp.convert for all other types (int, float, bool, None, etc.)
             default_expr = exp.convert(col.default)
 
         constraints.append(exp.ColumnConstraint(kind=default_expr))
diff --git a/sqlspec/builder/_delete.py b/sqlspec/builder/_delete.py
index b49689060..5a84d8af1 100644
--- a/sqlspec/builder/_delete.py
+++ b/sqlspec/builder/_delete.py
@@ -4,7 +4,6 @@
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from sqlglot import exp
@@ -12,11 +11,11 @@
 from sqlspec.builder._base import QueryBuilder, SafeQuery
 from sqlspec.builder.mixins import DeleteFromClauseMixin, ReturningClauseMixin, WhereClauseMixin
 from sqlspec.core.result import SQLResult
+from sqlspec.exceptions import SQLBuilderError
 
 __all__ = ("Delete",)
 
 
-@dataclass(unsafe_hash=True)
 class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromClauseMixin):
     """Builder for DELETE statements.
 
@@ -25,7 +24,8 @@ class Delete(QueryBuilder, WhereClauseMixin, ReturningClauseMixin, DeleteFromCla
     operations to maintain cross-dialect compatibility and safety.
     """
 
-    _table: "Optional[str]" = field(default=None, init=False)
+    __slots__ = ("_table",)
+    _expression: Optional[exp.Expression]
 
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize DELETE with optional table.
@@ -35,6 +35,7 @@ def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
             **kwargs: Additional QueryBuilder arguments
         """
         super().__init__(**kwargs)
+        self._initialize_expression()
 
         self._table = None
 
@@ -69,8 +70,6 @@ def build(self) -> "SafeQuery":
         """
 
         if not self._table:
-            from sqlspec.exceptions import SQLBuilderError
-
             msg = "DELETE requires a table to be specified. Use from() to set the table."
             raise SQLBuilderError(msg)
 
diff --git a/sqlspec/builder/_insert.py b/sqlspec/builder/_insert.py
index b8bb7beff..286360f48 100644
--- a/sqlspec/builder/_insert.py
+++ b/sqlspec/builder/_insert.py
@@ -4,8 +4,7 @@
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Final, Optional
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -21,15 +20,14 @@
 
 __all__ = ("Insert",)
 
-ERR_MSG_TABLE_NOT_SET = "The target table must be set using .into() before adding values."
-ERR_MSG_VALUES_COLUMNS_MISMATCH = (
+ERR_MSG_TABLE_NOT_SET: Final[str] = "The target table must be set using .into() before adding values."
+ERR_MSG_VALUES_COLUMNS_MISMATCH: Final[str] = (
     "Number of values ({values_len}) does not match the number of specified columns ({columns_len})."
 )
-ERR_MSG_INTERNAL_EXPRESSION_TYPE = "Internal error: expression is not an Insert instance as expected."
-ERR_MSG_EXPRESSION_NOT_INITIALIZED = "Internal error: base expression not initialized."
+ERR_MSG_INTERNAL_EXPRESSION_TYPE: Final[str] = "Internal error: expression is not an Insert instance as expected."
+ERR_MSG_EXPRESSION_NOT_INITIALIZED: Final[str] = "Internal error: base expression not initialized."
 
 
-@dataclass(unsafe_hash=True)
 class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSelectMixin, InsertIntoClauseMixin):
     """Builder for INSERT statements.
 
@@ -37,9 +35,7 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
     in a safe and dialect-agnostic manner with automatic parameter binding.
     """
 
-    _table: "Optional[str]" = field(default=None, init=False)
-    _columns: list[str] = field(default_factory=list, init=False)
-    _values_added_count: int = field(default=0, init=False)
+    __slots__ = ("_columns", "_table", "_values_added_count")
 
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize INSERT with optional table.
@@ -50,9 +46,12 @@ def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """
         super().__init__(**kwargs)
 
-        self._table = None
-        self._columns = []
-        self._values_added_count = 0
+        # Initialize Insert-specific attributes
+        self._table: Optional[str] = None
+        self._columns: list[str] = []
+        self._values_added_count: int = 0
+
+        self._initialize_expression()
 
         if table:
             self.into(table)
@@ -91,16 +90,22 @@ def _get_insert_expression(self) -> exp.Insert:
             raise SQLBuilderError(ERR_MSG_INTERNAL_EXPRESSION_TYPE)
         return self._expression
 
-    def values(self, *values: Any) -> "Self":
+    def values(self, *values: Any, **kwargs: Any) -> "Self":
         """Adds a row of values to the INSERT statement.
 
         This method can be called multiple times to insert multiple rows,
         resulting in a multi-row INSERT statement like `VALUES (...), (...)`.
 
+        Supports:
+        - values(val1, val2, val3)
+        - values(col1=val1, col2=val2)
+        - values(mapping)
+
         Args:
             *values: The values for the row to be inserted. The number of values
                      must match the number of columns set by `columns()`, if `columns()` was called
                      and specified any non-empty list of columns.
+            **kwargs: Column-value pairs for named values.
 
         Returns:
             The current builder instance for method chaining.
@@ -113,36 +118,49 @@ def values(self, *values: Any) -> "Self":
         if not self._table:
             raise SQLBuilderError(ERR_MSG_TABLE_NOT_SET)
 
+        if kwargs:
+            if values:
+                msg = "Cannot mix positional values with keyword values."
+                raise SQLBuilderError(msg)
+            return self.values_from_dict(kwargs)
+
+        if len(values) == 1:
+            try:
+                values_0 = values[0]
+                if hasattr(values_0, "items"):
+                    return self.values_from_dict(values_0)
+            except (AttributeError, TypeError):
+                pass
+
         insert_expr = self._get_insert_expression()
 
         if self._columns and len(values) != len(self._columns):
             msg = ERR_MSG_VALUES_COLUMNS_MISMATCH.format(values_len=len(values), columns_len=len(self._columns))
             raise SQLBuilderError(msg)
 
-        param_names = []
+        value_placeholders: list[exp.Expression] = []
         for i, value in enumerate(values):
-            # Try to use column name if available, otherwise use position-based name
-            if self._columns and i < len(self._columns):
-                column_name = (
-                    str(self._columns[i]).split(".")[-1] if "." in str(self._columns[i]) else str(self._columns[i])
-                )
-                param_name = self._generate_unique_parameter_name(column_name)
+            if isinstance(value, exp.Expression):
+                value_placeholders.append(value)
             else:
-                param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
-            _, param_name = self.add_parameter(value, name=param_name)
-            param_names.append(param_name)
-        value_placeholders = tuple(exp.var(name) for name in param_names)
-
-        current_values_expression = insert_expr.args.get("expression")
-
+                if self._columns and i < len(self._columns):
+                    column_str = str(self._columns[i])
+                    column_name = column_str.rsplit(".", maxsplit=1)[-1] if "." in column_str else column_str
+                    param_name = self._generate_unique_parameter_name(column_name)
+                else:
+                    param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
+                _, param_name = self.add_parameter(value, name=param_name)
+                value_placeholders.append(exp.var(param_name))
+
+        tuple_expr = exp.Tuple(expressions=value_placeholders)
         if self._values_added_count == 0:
-            new_values_node = exp.Values(expressions=[exp.Tuple(expressions=list(value_placeholders))])
-            insert_expr.set("expression", new_values_node)
-        elif isinstance(current_values_expression, exp.Values):
-            current_values_expression.expressions.append(exp.Tuple(expressions=list(value_placeholders)))
+            insert_expr.set("expression", exp.Values(expressions=[tuple_expr]))
         else:
-            new_values_node = exp.Values(expressions=[exp.Tuple(expressions=list(value_placeholders))])
-            insert_expr.set("expression", new_values_node)
+            current_values = insert_expr.args.get("expression")
+            if isinstance(current_values, exp.Values):
+                current_values.expressions.append(tuple_expr)
+            else:
+                insert_expr.set("expression", exp.Values(expressions=[tuple_expr]))
 
         self._values_added_count += 1
         return self
@@ -165,10 +183,11 @@ def values_from_dict(self, data: "Mapping[str, Any]") -> "Self":
         if not self._table:
             raise SQLBuilderError(ERR_MSG_TABLE_NOT_SET)
 
+        data_keys = list(data.keys())
         if not self._columns:
-            self.columns(*data.keys())
-        elif set(self._columns) != set(data.keys()):
-            msg = f"Dictionary keys {set(data.keys())} do not match existing columns {set(self._columns)}."
+            self.columns(*data_keys)
+        elif set(self._columns) != set(data_keys):
+            msg = f"Dictionary keys {set(data_keys)} do not match existing columns {set(self._columns)}."
             raise SQLBuilderError(msg)
 
         return self.values(*[data[col] for col in self._columns])
@@ -222,18 +241,14 @@ def on_conflict_do_nothing(self) -> "Self":
             For a more general solution, you might need dialect-specific handling.
         """
         insert_expr = self._get_insert_expression()
-        try:
-            on_conflict = exp.OnConflict(this=None, expressions=[])
-            insert_expr.set("on", on_conflict)
-        except AttributeError:
-            pass
+        insert_expr.set("on", exp.OnConflict(this=None, expressions=[]))
         return self
 
-    def on_duplicate_key_update(self, **set_values: Any) -> "Self":
+    def on_duplicate_key_update(self, **_: Any) -> "Self":
         """Adds an ON DUPLICATE KEY UPDATE clause (MySQL syntax).
 
         Args:
-            **set_values: Column-value pairs to update on duplicate key.
+            **_: Column-value pairs to update on duplicate key.
 
         Returns:
             The current builder instance for method chaining.
diff --git a/sqlspec/builder/_merge.py b/sqlspec/builder/_merge.py
index a788f5545..b97c749f9 100644
--- a/sqlspec/builder/_merge.py
+++ b/sqlspec/builder/_merge.py
@@ -4,7 +4,7 @@
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass
+from typing import Any, Optional
 
 from sqlglot import exp
 
@@ -22,7 +22,6 @@
 __all__ = ("Merge",)
 
 
-@dataclass(unsafe_hash=True)
 class Merge(
     QueryBuilder,
     MergeUsingClauseMixin,
@@ -38,6 +37,22 @@ class Merge(
     (also known as UPSERT in some databases) with automatic parameter binding and validation.
     """
 
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
+
+    def __init__(self, target_table: Optional[str] = None, **kwargs: Any) -> None:
+        """Initialize MERGE with optional target table.
+
+        Args:
+            target_table: Target table name
+            **kwargs: Additional QueryBuilder arguments
+        """
+        super().__init__(**kwargs)
+        self._initialize_expression()
+
+        if target_table:
+            self.into(target_table)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult]":
         """Return the expected result type for this builder.
diff --git a/sqlspec/builder/_parsing_utils.py b/sqlspec/builder/_parsing_utils.py
index 6f95aa2d0..6b18cba58 100644
--- a/sqlspec/builder/_parsing_utils.py
+++ b/sqlspec/builder/_parsing_utils.py
@@ -5,7 +5,7 @@
 """
 
 import contextlib
-from typing import Any, Optional, Union, cast
+from typing import Any, Final, Optional, Union, cast
 
 from sqlglot import exp, maybe_parse, parse_one
 
@@ -33,9 +33,12 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
         return column_input
 
     if has_expression_attr(column_input):
-        attr_value = getattr(column_input, "_expression", None)
-        if isinstance(attr_value, exp.Expression):
-            return attr_value
+        try:
+            attr_value = column_input._expression
+            if isinstance(attr_value, exp.Expression):
+                return attr_value
+        except AttributeError:
+            pass
 
     return exp.maybe_parse(column_input) or exp.column(str(column_input))
 
@@ -102,7 +105,7 @@ def parse_condition_expression(
     if isinstance(condition_input, exp.Expression):
         return condition_input
 
-    tuple_condition_parts = 2
+    tuple_condition_parts: Final[int] = 2
     if isinstance(condition_input, tuple) and len(condition_input) == tuple_condition_parts:
         column, value = condition_input
         column_expr = parse_column_expression(column)
@@ -129,12 +132,9 @@ def parse_condition_expression(
     except Exception:
         try:
             parsed = exp.maybe_parse(condition_input)  # type: ignore[var-annotated]
-            if parsed:
-                return parsed  # type:ignore[no-any-return]
-        except Exception:  # noqa: S110
-            pass
-
-    return exp.condition(condition_input)
+            return parsed or exp.condition(condition_input)
+        except Exception:
+            return exp.condition(condition_input)
 
 
 __all__ = ("parse_column_expression", "parse_condition_expression", "parse_order_expression", "parse_table_expression")
diff --git a/sqlspec/builder/_select.py b/sqlspec/builder/_select.py
index e7a711623..5ccb8bd35 100644
--- a/sqlspec/builder/_select.py
+++ b/sqlspec/builder/_select.py
@@ -5,8 +5,7 @@
 """
 
 import re
-from dataclasses import dataclass, field
-from typing import Any, Optional, Union
+from typing import Any, Callable, Final, Optional, Union
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -29,10 +28,9 @@
 __all__ = ("Select",)
 
 
-TABLE_HINT_PATTERN = r"\b{}\b(\s+AS\s+\w+)?"
+TABLE_HINT_PATTERN: Final[str] = r"\b{}\b(\s+AS\s+\w+)?"
 
 
-@dataclass
 class Select(
     QueryBuilder,
     WhereClauseMixin,
@@ -58,9 +56,8 @@ class Select(
         >>> result = driver.execute(builder)
     """
 
-    _with_parts: "dict[str, Union[exp.CTE, Select]]" = field(default_factory=dict, init=False)
-    _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
-    _hints: "list[dict[str, object]]" = field(default_factory=list, init=False, repr=False)
+    __slots__ = ("_hints", "_with_parts")
+    _expression: Optional[exp.Expression]
 
     def __init__(self, *columns: str, **kwargs: Any) -> None:
         """Initialize SELECT with optional columns.
@@ -75,11 +72,11 @@ def __init__(self, *columns: str, **kwargs: Any) -> None:
         """
         super().__init__(**kwargs)
 
-        self._with_parts = {}
-        self._expression = None
-        self._hints = []
+        # Initialize Select-specific attributes
+        self._with_parts: dict[str, Union[exp.CTE, Select]] = {}
+        self._hints: list[dict[str, object]] = []
 
-        self._create_base_expression()
+        self._initialize_expression()
 
         if columns:
             self.select(*columns)
@@ -93,7 +90,8 @@ def _expected_result_type(self) -> "type[SQLResult]":
         """
         return SQLResult
 
-    def _create_base_expression(self) -> "exp.Select":
+    def _create_base_expression(self) -> exp.Select:
+        """Create base SELECT expression."""
         if self._expression is None or not isinstance(self._expression, exp.Select):
             self._expression = exp.Select()
         return self._expression
@@ -131,44 +129,42 @@ def build(self) -> "SafeQuery":
         if not self._hints:
             return safe_query
 
-        modified_expr = self._expression.copy() if self._expression else self._create_base_expression()
+        modified_expr = self._expression or self._create_base_expression()
 
         if isinstance(modified_expr, exp.Select):
             statement_hints = [h["hint"] for h in self._hints if h.get("location") == "statement"]
             if statement_hints:
-                hint_expressions = []
 
-                def parse_hint(hint: Any) -> exp.Expression:
-                    """Parse a single hint."""
+                def parse_hint_safely(hint: Any) -> exp.Expression:
                     try:
-                        hint_str = str(hint)  # Ensure hint is a string
+                        hint_str = str(hint)
                         hint_expr: Optional[exp.Expression] = exp.maybe_parse(hint_str, dialect=self.dialect_name)
-                        if hint_expr:
-                            return hint_expr
-                        return exp.Anonymous(this=hint_str)
+                        return hint_expr or exp.Anonymous(this=hint_str)
                     except Exception:
                         return exp.Anonymous(this=str(hint))
 
-                hint_expressions = [parse_hint(hint) for hint in statement_hints]
+                hint_expressions: list[exp.Expression] = [parse_hint_safely(hint) for hint in statement_hints]
 
                 if hint_expressions:
-                    hint_node = exp.Hint(expressions=hint_expressions)
-                    modified_expr.set("hint", hint_node)
+                    modified_expr.set("hint", exp.Hint(expressions=hint_expressions))
 
         modified_sql = modified_expr.sql(dialect=self.dialect_name, pretty=True)
 
-        table_hints = [h for h in self._hints if h.get("location") == "table" and h.get("table")]
-        if table_hints:
-            for th in table_hints:
-                table = str(th["table"])
-                hint = th["hint"]
+        for hint_dict in self._hints:
+            if hint_dict.get("location") == "table" and hint_dict.get("table"):
+                table = str(hint_dict["table"])
+                hint = str(hint_dict["hint"])
                 pattern = TABLE_HINT_PATTERN.format(re.escape(table))
-                compiled_pattern = re.compile(pattern, re.IGNORECASE)
 
-                def replacement_func(match: re.Match[str]) -> str:
-                    alias_part = match.group(1) or ""
-                    return f"/*+ {hint} */ {table}{alias_part}"  # noqa: B023
+                def make_replacement(hint_val: str, table_val: str) -> "Callable[[re.Match[str]], str]":
+                    def replacement_func(match: re.Match[str]) -> str:
+                        alias_part = match.group(1) or ""
+                        return f"/*+ {hint_val} */ {table_val}{alias_part}"
 
-                modified_sql = compiled_pattern.sub(replacement_func, modified_sql, count=1)
+                    return replacement_func
+
+                modified_sql = re.sub(
+                    pattern, make_replacement(hint, table), modified_sql, count=1, flags=re.IGNORECASE
+                )
 
         return SafeQuery(sql=modified_sql, parameters=safe_query.parameters, dialect=safe_query.dialect)
diff --git a/sqlspec/builder/_update.py b/sqlspec/builder/_update.py
index 0a2f4976a..3a4337802 100644
--- a/sqlspec/builder/_update.py
+++ b/sqlspec/builder/_update.py
@@ -4,7 +4,6 @@
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlglot import exp
@@ -27,7 +26,6 @@
 __all__ = ("Update",)
 
 
-@dataclass(unsafe_hash=True)
 class Update(
     QueryBuilder,
     WhereClauseMixin,
@@ -72,6 +70,9 @@ class Update(
         ```
     """
 
+    __slots__ = ("_table",)
+    _expression: Optional[exp.Expression]
+
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize UPDATE with optional table.
 
@@ -80,6 +81,7 @@ def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
             **kwargs: Additional QueryBuilder arguments
         """
         super().__init__(**kwargs)
+        self._initialize_expression()
 
         if table:
             self.table(table)
diff --git a/sqlspec/builder/mixins/_cte_and_set_ops.py b/sqlspec/builder/mixins/_cte_and_set_ops.py
index feb7af073..e2eb79d9b 100644
--- a/sqlspec/builder/mixins/_cte_and_set_ops.py
+++ b/sqlspec/builder/mixins/_cte_and_set_ops.py
@@ -2,6 +2,7 @@
 
 from typing import Any, Optional, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -10,10 +11,21 @@
 __all__ = ("CommonTableExpressionMixin", "SetOperationMixin")
 
 
+@trait
 class CommonTableExpressionMixin:
     """Mixin providing WITH clause (Common Table Expressions) support for SQL builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    _with_ctes: Any  # Provided by QueryBuilder
+    dialect: Any  # Provided by QueryBuilder
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def with_(
         self, name: str, query: Union[Any, str], recursive: bool = False, columns: Optional[list[str]] = None
@@ -42,22 +54,22 @@ def with_(
 
         cte_expr: Optional[exp.Expression] = None
         if isinstance(query, str):
-            cte_expr = exp.maybe_parse(query, dialect=self.dialect)  # type: ignore[attr-defined]
+            cte_expr = exp.maybe_parse(query, dialect=self.dialect)
         elif isinstance(query, exp.Expression):
             cte_expr = query
         else:
-            built_query = query.to_statement()  # pyright: ignore
+            built_query = query.to_statement()
             cte_sql = built_query.sql
-            cte_expr = exp.maybe_parse(cte_sql, dialect=self.dialect)  # type: ignore[attr-defined]
+            cte_expr = exp.maybe_parse(cte_sql, dialect=self.dialect)
 
             parameters = built_query.parameters
             if parameters:
                 if isinstance(parameters, dict):
                     for param_name, param_value in parameters.items():
-                        self.add_parameter(param_value, name=param_name)  # type: ignore[attr-defined]
+                        self.add_parameter(param_value, name=param_name)
                 elif isinstance(parameters, (list, tuple)):
                     for param_value in parameters:
-                        self.add_parameter(param_value)  # type: ignore[attr-defined]
+                        self.add_parameter(param_value)
 
         if not cte_expr:
             msg = f"Could not parse CTE query: {query}"
@@ -68,29 +80,42 @@ def with_(
         else:
             cte_alias_expr = exp.alias_(cte_expr, name)
 
-        existing_with = self._expression.args.get("with")  # pyright: ignore
+        existing_with = self._expression.args.get("with")
         if existing_with:
             existing_with.expressions.append(cte_alias_expr)
             if recursive:
                 existing_with.set("recursive", recursive)
         else:
-            self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)  # type: ignore[union-attr]
-            if recursive:
-                with_clause = self._expression.find(exp.With)
-                if with_clause:
-                    with_clause.set("recursive", recursive)
-            self._with_ctes[name] = exp.CTE(this=cte_expr, alias=exp.to_table(name))  # type: ignore[attr-defined]
+            # Only SELECT, INSERT, UPDATE support WITH clauses
+            if hasattr(self._expression, "with_") and isinstance(
+                self._expression, (exp.Select, exp.Insert, exp.Update)
+            ):
+                self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)
+                if recursive:
+                    with_clause = self._expression.find(exp.With)
+                    if with_clause:
+                        with_clause.set("recursive", recursive)
+            self._with_ctes[name] = exp.CTE(this=cte_expr, alias=exp.to_table(name))
 
         return self
 
 
+@trait
 class SetOperationMixin:
     """Mixin providing set operations (UNION, INTERSECT, EXCEPT) for SELECT builders."""
 
-    _expression: Any = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     _parameters: dict[str, Any]
     dialect: Any = None
 
+    def build(self) -> Any:
+        """Build the query - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
     def union(self, other: Any, all_: bool = False) -> Self:
         """Combine this query with another using UNION.
 
@@ -104,7 +129,7 @@ def union(self, other: Any, all_: bool = False) -> Self:
         Returns:
             The new builder instance for the union query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
@@ -124,9 +149,11 @@ def union(self, other: Any, all_: bool = False) -> Self:
                     counter += 1
                     new_param_name = f"{param_name}_right_{counter}"
 
-                def rename_parameter(node: exp.Expression) -> exp.Expression:
-                    if isinstance(node, exp.Placeholder) and node.name == param_name:  # noqa: B023
-                        return exp.Placeholder(this=new_param_name)  # noqa: B023
+                def rename_parameter(
+                    node: exp.Expression, old_name: str = param_name, new_name: str = new_param_name
+                ) -> exp.Expression:
+                    if isinstance(node, exp.Placeholder) and node.name == old_name:
+                        return exp.Placeholder(this=new_name)
                     return node
 
                 right_expr = right_expr.transform(rename_parameter)
@@ -150,7 +177,7 @@ def intersect(self, other: Any) -> Self:
         Returns:
             The new builder instance for the intersect query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
@@ -178,7 +205,7 @@ def except_(self, other: Any) -> Self:
         Returns:
             The new builder instance for the except query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
diff --git a/sqlspec/builder/mixins/_delete_operations.py b/sqlspec/builder/mixins/_delete_operations.py
index 65276f8c2..31eaf2bfc 100644
--- a/sqlspec/builder/mixins/_delete_operations.py
+++ b/sqlspec/builder/mixins/_delete_operations.py
@@ -2,6 +2,7 @@
 
 from typing import Optional
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -10,10 +11,14 @@
 __all__ = ("DeleteFromClauseMixin",)
 
 
+@trait
 class DeleteFromClauseMixin:
     """Mixin providing FROM clause for DELETE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def from_(self, table: str) -> Self:
         """Set the target table for the DELETE statement.
diff --git a/sqlspec/builder/mixins/_insert_operations.py b/sqlspec/builder/mixins/_insert_operations.py
index 5f79ec40a..8bf9e1786 100644
--- a/sqlspec/builder/mixins/_insert_operations.py
+++ b/sqlspec/builder/mixins/_insert_operations.py
@@ -1,20 +1,28 @@
 """Insert operation mixins for SQL builders."""
 
 from collections.abc import Sequence
-from typing import Any, Optional, Union
+from typing import Any, Optional, TypeVar, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
+from sqlspec.protocols import SQLBuilderProtocol
+
+BuilderT = TypeVar("BuilderT", bound=SQLBuilderProtocol)
 
 __all__ = ("InsertFromSelectMixin", "InsertIntoClauseMixin", "InsertValuesMixin")
 
 
+@trait
 class InsertIntoClauseMixin:
     """Mixin providing INTO clause for INSERT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def into(self, table: str) -> Self:
         """Set the target table for the INSERT statement.
@@ -39,10 +47,26 @@ def into(self, table: str) -> Self:
         return self
 
 
+@trait
 class InsertValuesMixin:
     """Mixin providing VALUES and columns methods for INSERT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    _columns: Any  # Provided by QueryBuilder
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def columns(self, *columns: Union[str, exp.Expression]) -> Self:
         """Set the columns for the INSERT statement and synchronize the _columns attribute on the builder."""
@@ -54,7 +78,7 @@ def columns(self, *columns: Union[str, exp.Expression]) -> Self:
         column_exprs = [exp.column(col) if isinstance(col, str) else col for col in columns]
         self._expression.set("columns", column_exprs)
         try:
-            cols = self._columns  # type: ignore[attr-defined]
+            cols = self._columns
             if not columns:
                 cols.clear()
             else:
@@ -63,37 +87,94 @@ def columns(self, *columns: Union[str, exp.Expression]) -> Self:
             pass
         return self
 
-    def values(self, *values: Any) -> Self:
-        """Add a row of values to the INSERT statement, validating against _columns if set."""
+    def values(self, *values: Any, **kwargs: Any) -> Self:
+        """Add a row of values to the INSERT statement.
+
+        Supports:
+        - values(val1, val2, val3)
+        - values(col1=val1, col2=val2)
+        - values(mapping)
+
+        Args:
+            *values: Either positional values or a single mapping.
+            **kwargs: Column-value pairs.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
         if self._expression is None:
             self._expression = exp.Insert()
         if not isinstance(self._expression, exp.Insert):
             msg = "Cannot add values to a non-INSERT expression."
             raise SQLBuilderError(msg)
-        try:
-            _columns = self._columns  # type: ignore[attr-defined]
-            if _columns and len(values) != len(_columns):
-                msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(_columns)})."
+
+        if kwargs:
+            if values:
+                msg = "Cannot mix positional values with keyword values."
                 raise SQLBuilderError(msg)
-        except AttributeError:
-            pass
-        row_exprs = []
-        for i, v in enumerate(values):
-            if isinstance(v, exp.Expression):
-                row_exprs.append(v)
-            else:
-                # Try to use column name if available, otherwise use position-based name
-                try:
-                    _columns = self._columns  # type: ignore[attr-defined]
-                    if _columns and i < len(_columns):
-                        column_name = str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
-                        param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                    else:
-                        param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
-                except AttributeError:
-                    param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
-                _, param_name = self.add_parameter(v, name=param_name)  # type: ignore[attr-defined]
-                row_exprs.append(exp.var(param_name))
+            try:
+                _columns = self._columns
+                if not _columns:
+                    self.columns(*kwargs.keys())
+            except AttributeError:
+                pass
+            row_exprs = []
+            for col, val in kwargs.items():
+                if isinstance(val, exp.Expression):
+                    row_exprs.append(val)
+                else:
+                    column_name = col if isinstance(col, str) else str(col)
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    _, param_name = self.add_parameter(val, name=param_name)
+                    row_exprs.append(exp.var(param_name))
+        elif len(values) == 1 and hasattr(values[0], "items"):
+            mapping = values[0]
+            try:
+                _columns = self._columns
+                if not _columns:
+                    self.columns(*mapping.keys())
+            except AttributeError:
+                pass
+            row_exprs = []
+            for col, val in mapping.items():
+                if isinstance(val, exp.Expression):
+                    row_exprs.append(val)
+                else:
+                    column_name = col if isinstance(col, str) else str(col)
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    _, param_name = self.add_parameter(val, name=param_name)
+                    row_exprs.append(exp.var(param_name))
+        else:
+            try:
+                _columns = self._columns
+                if _columns and len(values) != len(_columns):
+                    msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(_columns)})."
+                    raise SQLBuilderError(msg)
+            except AttributeError:
+                pass
+            row_exprs = []
+            for i, v in enumerate(values):
+                if isinstance(v, exp.Expression):
+                    row_exprs.append(v)
+                else:
+                    try:
+                        _columns = self._columns
+                        if _columns and i < len(_columns):
+                            column_name = (
+                                str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
+                            )
+                            param_name = self._generate_unique_parameter_name(column_name)
+                        else:
+                            param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
+                    except AttributeError:
+                        param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
+                    _, param_name = self.add_parameter(v, name=param_name)
+                    row_exprs.append(exp.var(param_name))
+
         values_expr = exp.Values(expressions=[row_exprs])
         self._expression.set("expression", values_expr)
         return self
@@ -110,10 +191,21 @@ def add_values(self, values: Sequence[Any]) -> Self:
         return self.values(*values)
 
 
+@trait
 class InsertFromSelectMixin:
     """Mixin providing INSERT ... SELECT support for INSERT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    _table: Any  # Provided by QueryBuilder
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def from_select(self, select_builder: Any) -> Self:
         """Sets the INSERT source to a SELECT statement.
@@ -128,7 +220,7 @@ def from_select(self, select_builder: Any) -> Self:
             SQLBuilderError: If the table is not set or the select_builder is invalid.
         """
         try:
-            if not self._table:  # type: ignore[attr-defined]
+            if not self._table:
                 msg = "The target table must be set using .into() before adding values."
                 raise SQLBuilderError(msg)
         except AttributeError:
@@ -139,11 +231,11 @@ def from_select(self, select_builder: Any) -> Self:
         if not isinstance(self._expression, exp.Insert):
             msg = "Cannot set INSERT source on a non-INSERT expression."
             raise SQLBuilderError(msg)
-        subquery_parameters = select_builder._parameters  # pyright: ignore[attr-defined]
+        subquery_parameters = select_builder._parameters
         if subquery_parameters:
             for p_name, p_value in subquery_parameters.items():
-                self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
-        select_expr = select_builder._expression  # pyright: ignore[attr-defined]
+                self.add_parameter(p_value, name=p_name)
+        select_expr = select_builder._expression
         if select_expr and isinstance(select_expr, exp.Select):
             self._expression.set("expression", select_expr.copy())
         else:
diff --git a/sqlspec/builder/mixins/_join_operations.py b/sqlspec/builder/mixins/_join_operations.py
index bcdaef239..6b6d292a7 100644
--- a/sqlspec/builder/mixins/_join_operations.py
+++ b/sqlspec/builder/mixins/_join_operations.py
@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -13,9 +14,15 @@
 __all__ = ("JoinClauseMixin",)
 
 
+@trait
 class JoinClauseMixin:
     """Mixin providing JOIN clause methods for SELECT builders."""
 
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     def join(
         self,
         table: Union[str, exp.Expression, Any],
@@ -36,12 +43,12 @@ def join(
             if hasattr(table, "_expression") and getattr(table, "_expression", None) is not None:
                 table_expr_value = getattr(table, "_expression", None)
                 if table_expr_value is not None:
-                    subquery_exp = exp.paren(table_expr_value.copy())  # pyright: ignore
+                    subquery_exp = exp.paren(table_expr_value)
                 else:
                     subquery_exp = exp.paren(exp.Anonymous(this=""))
                 table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
             else:
-                subquery = table.build()  # pyright: ignore
+                subquery = table.build()
                 sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect", None)))
                 table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
@@ -99,12 +106,12 @@ def cross_join(self, table: Union[str, exp.Expression, Any], alias: Optional[str
             if hasattr(table, "_expression") and getattr(table, "_expression", None) is not None:
                 table_expr_value = getattr(table, "_expression", None)
                 if table_expr_value is not None:
-                    subquery_exp = exp.paren(table_expr_value.copy())  # pyright: ignore
+                    subquery_exp = exp.paren(table_expr_value)
                 else:
                     subquery_exp = exp.paren(exp.Anonymous(this=""))
                 table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
             else:
-                subquery = table.build()  # pyright: ignore
+                subquery = table.build()
                 sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect", None)))
                 table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
diff --git a/sqlspec/builder/mixins/_merge_operations.py b/sqlspec/builder/mixins/_merge_operations.py
index cb6432d30..c0fa70df6 100644
--- a/sqlspec/builder/mixins/_merge_operations.py
+++ b/sqlspec/builder/mixins/_merge_operations.py
@@ -2,6 +2,7 @@
 
 from typing import Any, Optional, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -18,10 +19,12 @@
 )
 
 
+@trait
 class MergeIntoClauseMixin:
     """Mixin providing INTO clause for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
 
     def into(self, table: Union[str, exp.Expression], alias: Optional[str] = None) -> Self:
         """Set the target table for the MERGE operation (INTO clause).
@@ -35,17 +38,24 @@ def into(self, table: Union[str, exp.Expression], alias: Optional[str] = None) -
             The current builder instance for method chaining.
         """
         if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # pyright: ignore
-        if not isinstance(self._expression, exp.Merge):  # pyright: ignore
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # pyright: ignore
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        if not isinstance(self._expression, exp.Merge):
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
         self._expression.set("this", exp.to_table(table, alias=alias) if isinstance(table, str) else table)
         return self
 
 
+@trait
 class MergeUsingClauseMixin:
     """Mixin providing USING clause for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Set the source data for the MERGE operation (USING clause).
@@ -73,7 +83,7 @@ def using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] =
             subquery_builder_parameters = source.parameters
             if subquery_builder_parameters:
                 for p_name, p_value in subquery_builder_parameters.items():
-                    self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+                    self.add_parameter(p_value, name=p_name)
 
             subquery_exp = exp.paren(getattr(source, "_expression", exp.select()))
             source_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
@@ -89,10 +99,12 @@ def using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] =
         return self
 
 
+@trait
 class MergeOnClauseMixin:
     """Mixin providing ON clause for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
 
     def on(self, condition: Union[str, exp.Expression]) -> Self:
         """Set the join condition for the MERGE operation (ON clause).
@@ -131,10 +143,22 @@ def on(self, condition: Union[str, exp.Expression]) -> Self:
         return self
 
 
+@trait
 class MergeMatchedClauseMixin:
     """Mixin providing WHEN MATCHED THEN ... clauses for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def _add_when_clause(self, when_clause: exp.When) -> None:
         """Helper to add a WHEN clause to the MERGE statement.
@@ -143,9 +167,9 @@ def _add_when_clause(self, when_clause: exp.When) -> None:
             when_clause: The WHEN clause to add.
         """
         if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # type: ignore[misc]
         if not isinstance(self._expression, exp.Merge):
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # type: ignore[misc]
 
         whens = self._expression.args.get("whens")
         if not whens:
@@ -175,8 +199,8 @@ def when_matched_then_update(
             column_name = col if isinstance(col, str) else str(col)
             if "." in column_name:
                 column_name = column_name.split(".")[-1]
-            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+            param_name = self._generate_unique_parameter_name(column_name)
+            param_name = self.add_parameter(val, name=param_name)[1]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {"matched": True, "then": exp.Update(expressions=update_expressions)}
@@ -238,10 +262,28 @@ def when_matched_then_delete(self, condition: Optional[Union[str, exp.Expression
         return self
 
 
+@trait
 class MergeNotMatchedClauseMixin:
     """Mixin providing WHEN NOT MATCHED THEN ... clauses for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _add_when_clause(self, when_clause: exp.When) -> None:
+        """Helper to add a WHEN clause to the MERGE statement - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def when_not_matched_then_insert(
         self,
@@ -278,8 +320,8 @@ def when_not_matched_then_insert(
                 column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
                 if "." in column_name:
                     column_name = column_name.split(".")[-1]
-                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                param_name = self._generate_unique_parameter_name(column_name)
+                param_name = self.add_parameter(val, name=param_name)[1]
                 parameterized_values.append(exp.var(param_name))
 
             insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
@@ -316,14 +358,32 @@ def when_not_matched_then_insert(
             when_args["this"] = condition_expr
 
         when_clause = exp.When(**when_args)
-        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        self._add_when_clause(when_clause)
         return self
 
 
+@trait
 class MergeNotMatchedBySourceClauseMixin:
     """Mixin providing WHEN NOT MATCHED BY SOURCE THEN ... clauses for MERGE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _add_when_clause(self, when_clause: exp.When) -> None:
+        """Helper to add a WHEN clause to the MERGE statement - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def when_not_matched_by_source_then_update(
         self, set_values: dict[str, Any], condition: Optional[Union[str, exp.Expression]] = None
@@ -347,8 +407,8 @@ def when_not_matched_by_source_then_update(
             column_name = col if isinstance(col, str) else str(col)
             if "." in column_name:
                 column_name = column_name.split(".")[-1]
-            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+            param_name = self._generate_unique_parameter_name(column_name)
+            param_name = self.add_parameter(val, name=param_name)[1]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {
@@ -375,7 +435,7 @@ def when_not_matched_by_source_then_update(
             when_args["this"] = condition_expr
 
         when_clause = exp.When(**when_args)
-        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        self._add_when_clause(when_clause)
         return self
 
     def when_not_matched_by_source_then_delete(self, condition: Optional[Union[str, exp.Expression]] = None) -> Self:
@@ -412,5 +472,5 @@ def when_not_matched_by_source_then_delete(self, condition: Optional[Union[str,
             when_args["this"] = condition_expr
 
         when_clause = exp.When(**when_args)
-        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        self._add_when_clause(when_clause)
         return self
diff --git a/sqlspec/builder/mixins/_order_limit_operations.py b/sqlspec/builder/mixins/_order_limit_operations.py
index 386ba24bc..a521f2b2f 100644
--- a/sqlspec/builder/mixins/_order_limit_operations.py
+++ b/sqlspec/builder/mixins/_order_limit_operations.py
@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -14,10 +15,14 @@
 __all__ = ("LimitOffsetClauseMixin", "OrderByClauseMixin", "ReturningClauseMixin")
 
 
+@trait
 class OrderByClauseMixin:
     """Mixin providing ORDER BY clause."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def order_by(self, *items: Union[str, exp.Ordered], desc: bool = False) -> Self:
         """Add ORDER BY clause.
@@ -50,10 +55,14 @@ def order_by(self, *items: Union[str, exp.Ordered], desc: bool = False) -> Self:
         return cast("Self", builder)
 
 
+@trait
 class LimitOffsetClauseMixin:
     """Mixin providing LIMIT and OFFSET clauses."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def limit(self, value: int) -> Self:
         """Add LIMIT clause.
@@ -94,10 +103,13 @@ def offset(self, value: int) -> Self:
         return cast("Self", builder)
 
 
+@trait
 class ReturningClauseMixin:
     """Mixin providing RETURNING clause."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def returning(self, *columns: Union[str, exp.Expression]) -> Self:
         """Add RETURNING clause to the statement.
diff --git a/sqlspec/builder/mixins/_pivot_operations.py b/sqlspec/builder/mixins/_pivot_operations.py
index bbe2a9663..a55d27389 100644
--- a/sqlspec/builder/mixins/_pivot_operations.py
+++ b/sqlspec/builder/mixins/_pivot_operations.py
@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 
 if TYPE_CHECKING:
@@ -12,10 +13,14 @@
 __all__ = ("PivotClauseMixin", "UnpivotClauseMixin")
 
 
+@trait
 class PivotClauseMixin:
     """Mixin class to add PIVOT functionality to a Select."""
 
-    _expression: "Optional[exp.Expression]" = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     dialect: "DialectType" = None
 
     def pivot(
@@ -79,10 +84,14 @@ def pivot(
         return cast("Select", self)
 
 
+@trait
 class UnpivotClauseMixin:
     """Mixin class to add UNPIVOT functionality to a Select."""
 
-    _expression: "Optional[exp.Expression]" = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     dialect: "DialectType" = None
 
     def unpivot(
diff --git a/sqlspec/builder/mixins/_select_operations.py b/sqlspec/builder/mixins/_select_operations.py
index 9bbe5b5c7..7afda22c5 100644
--- a/sqlspec/builder/mixins/_select_operations.py
+++ b/sqlspec/builder/mixins/_select_operations.py
@@ -3,6 +3,7 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -11,17 +12,20 @@
 from sqlspec.utils.type_guards import has_query_builder_parameters, is_expression
 
 if TYPE_CHECKING:
-    from sqlspec.builder._base import QueryBuilder
     from sqlspec.builder._column import Column, FunctionColumn
     from sqlspec.protocols import SelectBuilderProtocol, SQLBuilderProtocol
 
 __all__ = ("CaseBuilder", "SelectClauseMixin")
 
 
+@trait
 class SelectClauseMixin:
     """Consolidated mixin providing all SELECT-related clauses and functionality."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def select(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn"]) -> Self:
         """Add columns to SELECT clause.
@@ -529,7 +533,7 @@ def case_(self, alias: "Optional[str]" = None) -> "CaseBuilder":
         Returns:
             CaseBuilder: A CaseBuilder instance for building the CASE expression.
         """
-        builder = cast("QueryBuilder", self)  # pyright: ignore
+        builder = cast("SelectBuilderProtocol", self)
         return CaseBuilder(builder, alias)
 
 
@@ -537,15 +541,15 @@ def case_(self, alias: "Optional[str]" = None) -> "CaseBuilder":
 class CaseBuilder:
     """Builder for CASE expressions."""
 
-    _parent: "QueryBuilder"  # pyright: ignore
+    _parent: "SelectBuilderProtocol"
     _alias: Optional[str]
     _case_expr: exp.Case
 
-    def __init__(self, parent: "QueryBuilder", alias: "Optional[str]" = None) -> None:
+    def __init__(self, parent: "SelectBuilderProtocol", alias: "Optional[str]" = None) -> None:
         """Initialize CaseBuilder.
 
         Args:
-            parent: The parent builder.
+            parent: The parent builder with select capabilities.
             alias: Optional alias for the CASE expression.
         """
         self._parent = parent
@@ -589,11 +593,11 @@ def else_(self, value: "Any") -> "CaseBuilder":
         self._case_expr.set("default", value_expr)
         return self
 
-    def end(self) -> "QueryBuilder":
+    def end(self) -> "SelectBuilderProtocol":
         """Finalize the CASE expression and add it to the SELECT clause.
 
         Returns:
             The parent builder instance.
         """
         select_expr = exp.alias_(self._case_expr, self._alias) if self._alias else self._case_expr
-        return cast("QueryBuilder", self._parent.select(select_expr))  # type: ignore[attr-defined]
+        return self._parent.select(select_expr)
diff --git a/sqlspec/builder/mixins/_update_operations.py b/sqlspec/builder/mixins/_update_operations.py
index d832636df..daff5505c 100644
--- a/sqlspec/builder/mixins/_update_operations.py
+++ b/sqlspec/builder/mixins/_update_operations.py
@@ -3,6 +3,7 @@
 from collections.abc import Mapping
 from typing import Any, Optional, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -14,10 +15,14 @@
 MIN_SET_ARGS = 2
 
 
+@trait
 class UpdateTableClauseMixin:
     """Mixin providing TABLE clause for UPDATE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def table(self, table_name: str, alias: Optional[str] = None) -> Self:
         """Set the table to update.
@@ -37,10 +42,24 @@ def table(self, table_name: str, alias: Optional[str] = None) -> Self:
         return self
 
 
+@trait
 class UpdateSetClauseMixin:
     """Mixin providing SET clause for UPDATE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def set(self, *args: Any, **kwargs: Any) -> Self:
         """Set columns and values for the UPDATE statement.
@@ -79,14 +98,13 @@ def set(self, *args: Any, **kwargs: Any) -> Self:
                 value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                 if has_query_builder_parameters(val):
                     for p_name, p_value in val.parameters.items():
-                        self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+                        self.add_parameter(p_value, name=p_name)
             else:
                 column_name = col if isinstance(col, str) else str(col)
-                # Extract just the column part if table.column format
                 if "." in column_name:
                     column_name = column_name.split(".")[-1]
-                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                param_name = self._generate_unique_parameter_name(column_name)
+                param_name = self.add_parameter(val, name=param_name)[1]
                 value_expr = exp.Placeholder(this=param_name)
             assignments.append(exp.EQ(this=col_expr, expression=value_expr))
         elif (len(args) == 1 and isinstance(args[0], Mapping)) or kwargs:
@@ -100,14 +118,13 @@ def set(self, *args: Any, **kwargs: Any) -> Self:
                     value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                     if has_query_builder_parameters(val):
                         for p_name, p_value in val.parameters.items():
-                            self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+                            self.add_parameter(p_value, name=p_name)
                 else:
-                    # Extract column name for parameter naming
                     column_name = col if isinstance(col, str) else str(col)
                     if "." in column_name:
                         column_name = column_name.split(".")[-1]
-                    param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                    param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    param_name = self.add_parameter(val, name=param_name)[1]
                     value_expr = exp.Placeholder(this=param_name)
                 assignments.append(exp.EQ(this=exp.column(col), expression=value_expr))
         else:
@@ -118,9 +135,15 @@ def set(self, *args: Any, **kwargs: Any) -> Self:
         return self
 
 
+@trait
 class UpdateFromClauseMixin:
     """Mixin providing FROM clause for UPDATE builders (e.g., PostgreSQL style)."""
 
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Add a FROM clause to the UPDATE statement.
 
@@ -134,7 +157,7 @@ def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = N
         Raises:
             SQLBuilderError: If the current expression is not an UPDATE statement.
         """
-        if self._expression is None or not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
+        if self._expression is None or not isinstance(self._expression, exp.Update):
             msg = "Cannot add FROM clause to non-UPDATE expression. Set the main table first."
             raise SQLBuilderError(msg)
         table_expr: exp.Expression
@@ -152,9 +175,9 @@ def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = N
         else:
             msg = f"Unsupported table type for FROM clause: {type(table)}"
             raise SQLBuilderError(msg)
-        if self._expression.args.get("from") is None:  # type: ignore[attr-defined]
-            self._expression.set("from", exp.From(expressions=[]))  # type: ignore[attr-defined]
-        from_clause = self._expression.args["from"]  # type: ignore[attr-defined]
+        if self._expression.args.get("from") is None:
+            self._expression.set("from", exp.From(expressions=[]))
+        from_clause = self._expression.args["from"]
         if hasattr(from_clause, "append"):
             from_clause.append("expressions", table_expr)
         else:
diff --git a/sqlspec/builder/mixins/_where_clause.py b/sqlspec/builder/mixins/_where_clause.py
index 9c819bcec..159ae935c 100644
--- a/sqlspec/builder/mixins/_where_clause.py
+++ b/sqlspec/builder/mixins/_where_clause.py
@@ -3,6 +3,7 @@
 
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -27,9 +28,10 @@ def _extract_column_name(column: Union[str, exp.Column]) -> str:
         return column
     if isinstance(column, exp.Column):
         # Extract the column name from SQLGlot Column expression
-        if column.this and hasattr(column.this, "this"):
+        try:
             return str(column.this.this)
-        return str(column.this) if column.this else "column"
+        except AttributeError:
+            return str(column.this) if column.this else "column"
     return "column"
 
 
@@ -40,9 +42,15 @@ def _extract_column_name(column: Union[str, exp.Column]) -> str:
 __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
 
+@trait
 class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     def _handle_in_operator(
         self, column_exp: exp.Expression, value: Any, column_name: str = "column"
     ) -> exp.Expression:
@@ -52,13 +60,13 @@ def _handle_in_operator(
             placeholders = []
             for i, v in enumerate(value):
                 if len(value) == 1:
-                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(column_name)
                 else:
-                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
                 _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.In(this=column_exp, expressions=placeholders)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         return exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)])
 
@@ -71,13 +79,13 @@ def _handle_not_in_operator(
             placeholders = []
             for i, v in enumerate(value):
                 if len(value) == 1:
-                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(column_name)
                 else:
-                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
                 _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.Not(this=exp.In(this=column_exp, expressions=placeholders))
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         return exp.Not(this=exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)]))
 
@@ -98,8 +106,8 @@ def _handle_between_operator(
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
             _, low_param = builder.add_parameter(low, name=low_param)
             _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Between(
@@ -115,8 +123,8 @@ def _handle_not_between_operator(
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
             _, low_param = builder.add_parameter(low, name=low_param)
             _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Not(
@@ -137,7 +145,7 @@ def _process_tuple_condition(self, condition: tuple) -> exp.Expression:
         if len(condition) == 2:
             # (column, value) tuple for equality
             value = condition[1]
-            param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = builder._generate_unique_parameter_name(column_name)
             _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
 
@@ -147,35 +155,35 @@ def _process_tuple_condition(self, condition: tuple) -> exp.Expression:
             value = condition[2]
 
             if operator == "=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator in {"!=", "<>"}:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.NEQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "LIKE":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "NOT LIKE":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
@@ -222,7 +230,7 @@ def where(
         Returns:
             The current builder instance for method chaining.
         """
-        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
+        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
 
@@ -274,7 +282,7 @@ def where_eq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column = value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.eq(exp.Placeholder(this=param_name))
@@ -284,7 +292,7 @@ def where_neq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column != value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.neq(exp.Placeholder(this=param_name))
@@ -294,7 +302,7 @@ def where_lt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column < value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.LT(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -304,7 +312,7 @@ def where_lte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column <= value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -314,7 +322,7 @@ def where_gt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column > value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.GT(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -324,7 +332,7 @@ def where_gte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column >= value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -334,8 +342,8 @@ def where_between(self, column: Union[str, exp.Column], low: Any, high: Any) ->
         """Add WHERE column BETWEEN low AND high clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
         _, low_param = builder.add_parameter(low, name=low_param)
         _, high_param = builder.add_parameter(high, name=high_param)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
@@ -346,7 +354,7 @@ def where_like(self, column: Union[str, exp.Column], pattern: str, escape: Optio
         """Add WHERE column LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         if escape is not None:
@@ -360,7 +368,7 @@ def where_not_like(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column NOT LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.like(exp.Placeholder(this=param_name)).not_()
@@ -370,7 +378,7 @@ def where_ilike(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column ILIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.ilike(exp.Placeholder(this=param_name))
@@ -399,7 +407,7 @@ def where_in(self, column: Union[str, exp.Column], values: Any) -> Self:
                 sql_str = subquery.sql
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=builder.dialect_name))  # pyright: ignore
                 # Merge subquery parameters into parent builder
-                if hasattr(subquery, "parameters"):
+                if hasattr(subquery, "parameters") and isinstance(subquery.parameters, dict):  # pyright: ignore[reportAttributeAccessIssue]
                     for param_name, param_value in subquery.parameters.items():  # pyright: ignore[reportAttributeAccessIssue]
                         builder.add_parameter(param_value, name=param_name)
             else:
@@ -413,9 +421,9 @@ def where_in(self, column: Union[str, exp.Column], values: Any) -> Self:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         condition = col_expr.isin(*parameters)
@@ -442,9 +450,9 @@ def where_not_in(self, column: Union[str, exp.Column], values: Any) -> Self:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         condition = exp.Not(this=col_expr.isin(*parameters))
@@ -532,9 +540,9 @@ def where_any(self, column: Union[str, exp.Column], values: Any) -> Self:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
@@ -572,9 +580,9 @@ def where_not_any(self, column: Union[str, exp.Column], values: Any) -> Self:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
@@ -582,10 +590,14 @@ def where_not_any(self, column: Union[str, exp.Column], values: Any) -> Self:
         return self.where(condition)
 
 
+@trait
 class HavingClauseMixin:
     """Mixin providing HAVING clause for SELECT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def having(self, condition: Union[str, exp.Expression]) -> Self:
         """Add HAVING clause.
diff --git a/sqlspec/core/cache.py b/sqlspec/core/cache.py
index ec81d8365..064fb909a 100644
--- a/sqlspec/core/cache.py
+++ b/sqlspec/core/cache.py
@@ -245,19 +245,21 @@ def get(self, key: CacheKey) -> Optional[CacheValueT]:
             Cached value or None if not found or expired
         """
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 self._stats.record_miss()
                 return None
 
-            current_time: float = time.time()
-            ttl: Optional[int] = self._ttl
-            if ttl is not None and (current_time - node.timestamp) > ttl:
-                self._remove_node(node)
-                del self._cache[key]
-                self._stats.record_miss()
-                self._stats.record_eviction()
-                return None
+            # Optimize TTL check with early variable assignment
+            ttl = self._ttl
+            if ttl is not None:
+                current_time = time.time()
+                if (current_time - node.timestamp) > ttl:
+                    self._remove_node(node)
+                    del self._cache[key]
+                    self._stats.record_miss()
+                    self._stats.record_eviction()
+                    return None
 
             self._move_to_head(node)
             node.access_count += 1
@@ -272,7 +274,7 @@ def put(self, key: CacheKey, value: CacheValueT) -> None:
             value: Value to cache
         """
         with self._lock:
-            existing_node: Optional[CacheNode] = self._cache.get(key)
+            existing_node = self._cache.get(key)
             if existing_node is not None:
                 existing_node.value = value
                 existing_node.timestamp = time.time()
@@ -280,14 +282,13 @@ def put(self, key: CacheKey, value: CacheValueT) -> None:
                 self._move_to_head(existing_node)
                 return
 
-            new_node: CacheNode = CacheNode(key, value)
+            new_node = CacheNode(key, value)
             self._cache[key] = new_node
             self._add_to_head(new_node)
 
-            cache_size: int = len(self._cache)
-            max_size: int = self._max_size
-            if cache_size > max_size:
-                tail_node: Optional[CacheNode] = self._tail.prev
+            # Optimize size check with cached length
+            if len(self._cache) > self._max_size:
+                tail_node = self._tail.prev
                 if tail_node is not None and tail_node is not self._head:
                     self._remove_node(tail_node)
                     del self._cache[tail_node.key]
@@ -361,17 +362,13 @@ def __len__(self) -> int:
     def __contains__(self, key: CacheKey) -> bool:
         """Check if key exists in cache."""
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 return False
 
-            ttl: Optional[int] = self._ttl
-            if ttl is not None:
-                current_time: float = time.time()
-                if (current_time - node.timestamp) > ttl:
-                    return False
-
-            return True
+            # Optimize TTL check
+            ttl = self._ttl
+            return not (ttl is not None and time.time() - node.timestamp > ttl)
 
 
 @mypyc_attr(allow_interpreted_subclasses=False)
@@ -553,6 +550,8 @@ def _create_parameter_key(self, params: Any, config_hash: int) -> CacheKey:
         """
         # Create stable key from parameters and configuration
         try:
+            # Optimize type checking order
+            param_key: tuple[Any, ...]
             if isinstance(params, dict):
                 param_key = tuple(sorted(params.items()))
             elif isinstance(params, (list, tuple)):
@@ -560,12 +559,11 @@ def _create_parameter_key(self, params: Any, config_hash: int) -> CacheKey:
             else:
                 param_key = (params,)
 
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            return CacheKey(("parameters", param_key, config_hash))
         except (TypeError, ValueError):
-            param_key = (str(params), type(params).__name__)  # type: ignore[assignment]
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            # Fallback for unhashable types
+            param_key_fallback = (str(params), type(params).__name__)
+            return CacheKey(("parameters", param_key_fallback, config_hash))
 
     def clear(self) -> None:
         """Clear parameter cache."""
diff --git a/sqlspec/core/compiler.py b/sqlspec/core/compiler.py
index c722c4a73..5298d0dae 100644
--- a/sqlspec/core/compiler.py
+++ b/sqlspec/core/compiler.py
@@ -121,10 +121,11 @@ def __init__(
         self._hash: Optional[int] = None
 
     def __hash__(self) -> int:
-        """Cached hash value."""
+        """Cached hash value with optimization."""
         if self._hash is None:
-            hash_data = (self.compiled_sql, str(self.execution_parameters), self.operation_type, self.parameter_style)
-            self._hash = hash(hash_data)
+            # Optimize by avoiding str() conversion if possible
+            param_str = str(self.execution_parameters)
+            self._hash = hash((self.compiled_sql, param_str, self.operation_type, self.parameter_style))
         return self._hash
 
     def __eq__(self, other: object) -> bool:
@@ -229,16 +230,21 @@ def _compile_uncached(self, sql: str, parameters: Any, is_many: bool = False) ->
             CompiledSQL result
         """
         try:
+            # Cache dialect string to avoid repeated conversions
             dialect_str = str(self._config.dialect) if self._config.dialect else None
-            processed_sql, processed_params_tuple = self._parameter_processor.process(
+
+            # Process parameters in single call
+            processed_sql: str
+            processed_params: Any
+            processed_sql, processed_params = self._parameter_processor.process(
                 sql=sql,
                 parameters=parameters,
                 config=self._config.parameter_config,
                 dialect=dialect_str,
                 is_many=is_many,
             )
-            processed_params: Any = processed_params_tuple
 
+            # Optimize static compilation path
             if self._config.parameter_config.needs_static_script_compilation and processed_params is None:
                 sqlglot_sql = processed_sql
             else:
@@ -246,35 +252,39 @@ def _compile_uncached(self, sql: str, parameters: Any, is_many: bool = False) ->
                     sql, parameters, self._config.parameter_config, dialect_str
                 )
 
-            final_parameters: Any = processed_params
+            final_parameters = processed_params
             ast_was_transformed = False
+            expression = None
+            operation_type = "EXECUTE"
 
             if self._config.enable_parsing:
                 try:
+                    # Use copy=False for performance optimization
                     expression = sqlglot.parse_one(sqlglot_sql, dialect=dialect_str)
                     operation_type = self._detect_operation_type(expression)
 
-                    if self._config.parameter_config.ast_transformer:
-                        expression, final_parameters = self._config.parameter_config.ast_transformer(
-                            expression, processed_params
-                        )
+                    # Handle AST transformation if configured
+                    ast_transformer = self._config.parameter_config.ast_transformer
+                    if ast_transformer:
+                        expression, final_parameters = ast_transformer(expression, processed_params)
                         ast_was_transformed = True
 
                 except ParseError:
                     expression = None
                     operation_type = "EXECUTE"
-            else:
-                expression = None
-                operation_type = "EXECUTE"
 
+            # Optimize final SQL generation path
             if self._config.parameter_config.needs_static_script_compilation and processed_params is None:
                 final_sql, final_params = processed_sql, processed_params
             elif ast_was_transformed and expression is not None:
                 final_sql = expression.sql(dialect=dialect_str)
                 final_params = final_parameters
                 logger.debug("AST was transformed - final SQL: %s, final params: %s", final_sql, final_params)
-                if self._config.output_transformer:
-                    final_sql, final_params = self._config.output_transformer(final_sql, final_params)
+
+                # Apply output transformer if configured
+                output_transformer = self._config.output_transformer
+                if output_transformer:
+                    final_sql, final_params = output_transformer(final_sql, final_params)
             else:
                 final_sql, final_params = self._apply_final_transformations(
                     expression, processed_sql, final_parameters, dialect_str
@@ -305,15 +315,23 @@ def _make_cache_key(self, sql: str, parameters: Any) -> str:
         Returns:
             Cache key string
         """
+        # Optimize key generation by avoiding string conversion overhead
+        param_repr = repr(parameters)
+        dialect_str = str(self._config.dialect) if self._config.dialect else None
+        param_style = self._config.parameter_config.default_parameter_style.value
+
+        # Use direct tuple construction for better performance
         hash_data = (
             sql,
-            repr(parameters),
-            self._config.parameter_config.default_parameter_style.value,
-            str(self._config.dialect),
+            param_repr,
+            param_style,
+            dialect_str,
             self._config.enable_parsing,
             self._config.enable_transformations,
         )
-        hash_str = hashlib.sha256(str(hash_data).encode()).hexdigest()[:16]
+
+        # Optimize hash computation
+        hash_str = hashlib.sha256(str(hash_data).encode("utf-8")).hexdigest()[:16]
         return f"sql_{hash_str}"
 
     def _detect_operation_type(self, expression: "exp.Expression") -> str:
@@ -327,27 +345,29 @@ def _detect_operation_type(self, expression: "exp.Expression") -> str:
         Returns:
             Operation type string
         """
+        # Use isinstance for compatibility with mocks and inheritance
         if isinstance(expression, exp.Select):
-            return _OPERATION_TYPES["SELECT"]
+            return "SELECT"
         if isinstance(expression, exp.Insert):
-            return _OPERATION_TYPES["INSERT"]
+            return "INSERT"
         if isinstance(expression, exp.Update):
-            return _OPERATION_TYPES["UPDATE"]
+            return "UPDATE"
         if isinstance(expression, exp.Delete):
-            return _OPERATION_TYPES["DELETE"]
-        if isinstance(expression, (exp.Create, exp.Drop, exp.Alter)):
-            return _OPERATION_TYPES["DDL"]
-        if isinstance(expression, exp.Copy):
-            if expression.args["kind"] is True:
-                return _OPERATION_TYPES["COPY_FROM"]
-            if expression.args["kind"] is False:
-                return _OPERATION_TYPES["COPY_TO"]
-            return _OPERATION_TYPES["COPY"]
+            return "DELETE"
         if isinstance(expression, exp.Pragma):
-            return _OPERATION_TYPES["PRAGMA"]
+            return "PRAGMA"
         if isinstance(expression, exp.Command):
-            return _OPERATION_TYPES["EXECUTE"]
-        return _OPERATION_TYPES["UNKNOWN"]
+            return "EXECUTE"
+        if isinstance(expression, exp.Copy):
+            copy_kind = expression.args.get("kind")
+            if copy_kind is True:
+                return "COPY_FROM"
+            if copy_kind is False:
+                return "COPY_TO"
+            return "COPY"
+        if isinstance(expression, (exp.Create, exp.Drop, exp.Alter)):
+            return "DDL"
+        return "UNKNOWN"
 
     def _apply_final_transformations(
         self, expression: "Optional[exp.Expression]", sql: str, parameters: Any, dialect_str: "Optional[str]"
@@ -363,11 +383,12 @@ def _apply_final_transformations(
         Returns:
             Tuple of (final_sql, final_parameters)
         """
-        if self._config.output_transformer:
+        output_transformer = self._config.output_transformer
+        if output_transformer:
             if expression is not None:
                 ast_sql = expression.sql(dialect=dialect_str)
-                return self._config.output_transformer(ast_sql, parameters)
-            return self._config.output_transformer(sql, parameters)
+                return output_transformer(ast_sql, parameters)
+            return output_transformer(sql, parameters)
 
         return sql, parameters
 
diff --git a/sqlspec/core/parameters.py b/sqlspec/core/parameters.py
index c56a6b1eb..d92dfee9a 100644
--- a/sqlspec/core/parameters.py
+++ b/sqlspec/core/parameters.py
@@ -124,9 +124,11 @@ def __init__(self, value: Any, original_type: Optional[type] = None, semantic_na
         self._hash: Optional[int] = None
 
     def __hash__(self) -> int:
-        """Cached hash value."""
+        """Cached hash value with optimization."""
         if self._hash is None:
-            self._hash = hash((id(self.value), self.original_type, self.semantic_name))
+            # Optimize by avoiding tuple creation for common case
+            value_id = id(self.value)
+            self._hash = hash((value_id, self.original_type, self.semantic_name))
         return self._hash
 
     def __eq__(self, other: object) -> bool:
@@ -361,13 +363,15 @@ def extract_parameters(self, sql: str) -> "list[ParameterInfo]":
         Returns:
             List of ParameterInfo objects for each detected parameter
         """
-        if sql in self._parameter_cache:
-            return self._parameter_cache[sql]
+        cached_result = self._parameter_cache.get(sql)
+        if cached_result is not None:
+            return cached_result
 
         parameters: list[ParameterInfo] = []
         ordinal = 0
 
         for match in _PARAMETER_REGEX.finditer(sql):
+            # Fast rejection of comments and quotes
             if (
                 match.group("dquote")
                 or match.group("squote")
@@ -381,37 +385,52 @@ def extract_parameters(self, sql: str) -> "list[ParameterInfo]":
 
             position = match.start()
             placeholder_text = match.group(0)
-            name = None
-            style = None
+            name: Optional[str] = None
+            style: Optional[ParameterStyle] = None
 
-            if match.group("pyformat_named"):
+            # Optimize with elif chain for better branch prediction
+            pyformat_named = match.group("pyformat_named")
+            if pyformat_named:
                 style = ParameterStyle.NAMED_PYFORMAT
                 name = match.group("pyformat_name")
-            elif match.group("pyformat_pos"):
-                style = ParameterStyle.POSITIONAL_PYFORMAT
-            elif match.group("positional_colon"):
-                style = ParameterStyle.POSITIONAL_COLON
-                name = match.group("colon_num")
-            elif match.group("named_colon"):
-                style = ParameterStyle.NAMED_COLON
-                name = match.group("colon_name")
-            elif match.group("named_at"):
-                style = ParameterStyle.NAMED_AT
-                name = match.group("at_name")
-            elif match.group("numeric"):
-                style = ParameterStyle.NUMERIC
-                name = match.group("numeric_num")
-            elif match.group("named_dollar_param"):
-                style = ParameterStyle.NAMED_DOLLAR
-                name = match.group("dollar_param_name")
-            elif match.group("qmark"):
-                style = ParameterStyle.QMARK
+            else:
+                pyformat_pos = match.group("pyformat_pos")
+                if pyformat_pos:
+                    style = ParameterStyle.POSITIONAL_PYFORMAT
+                else:
+                    positional_colon = match.group("positional_colon")
+                    if positional_colon:
+                        style = ParameterStyle.POSITIONAL_COLON
+                        name = match.group("colon_num")
+                    else:
+                        named_colon = match.group("named_colon")
+                        if named_colon:
+                            style = ParameterStyle.NAMED_COLON
+                            name = match.group("colon_name")
+                        else:
+                            named_at = match.group("named_at")
+                            if named_at:
+                                style = ParameterStyle.NAMED_AT
+                                name = match.group("at_name")
+                            else:
+                                numeric = match.group("numeric")
+                                if numeric:
+                                    style = ParameterStyle.NUMERIC
+                                    name = match.group("numeric_num")
+                                else:
+                                    named_dollar_param = match.group("named_dollar_param")
+                                    if named_dollar_param:
+                                        style = ParameterStyle.NAMED_DOLLAR
+                                        name = match.group("dollar_param_name")
+                                    elif match.group("qmark"):
+                                        style = ParameterStyle.QMARK
 
             if style is not None:
-                param_info = ParameterInfo(
-                    name=name, style=style, position=position, ordinal=ordinal, placeholder_text=placeholder_text
+                parameters.append(
+                    ParameterInfo(
+                        name=name, style=style, position=position, ordinal=ordinal, placeholder_text=placeholder_text
+                    )
                 )
-                parameters.append(param_info)
                 ordinal += 1
 
         self._parameter_cache[sql] = parameters
@@ -567,26 +586,34 @@ def _convert_placeholders_to_style(
             msg = f"Unsupported target parameter style: {target_style}"
             raise ValueError(msg)
 
-        # Build a mapping of unique parameters to their ordinals
-        # This handles repeated parameters like $1, $2, $2 correctly
-        # Special case: QMARK (?) parameters converting to NUMERIC ($1, $2) need sequential numbering
+        # Optimize parameter style detection
         param_styles = {p.style for p in param_info}
-        use_sequential_for_qmark = param_styles == {ParameterStyle.QMARK} and target_style == ParameterStyle.NUMERIC
+        use_sequential_for_qmark = (
+            len(param_styles) == 1 and ParameterStyle.QMARK in param_styles and target_style == ParameterStyle.NUMERIC
+        )
 
+        # Build unique parameters mapping efficiently
         unique_params: dict[str, int] = {}
         for param in param_info:
-            if use_sequential_for_qmark and param.style == ParameterStyle.QMARK:
-                # For QMARK → NUMERIC conversion, each ? gets sequential numbering
-                param_key = f"{param.placeholder_text}_{param.ordinal}"
-            else:
-                # For all other cases, group by placeholder text
-                param_key = param.placeholder_text
+            param_key = (
+                f"{param.placeholder_text}_{param.ordinal}"
+                if use_sequential_for_qmark and param.style == ParameterStyle.QMARK
+                else param.placeholder_text
+            )
 
             if param_key not in unique_params:
                 unique_params[param_key] = len(unique_params)
 
+        # Convert SQL with optimized string operations
         converted_sql = sql
+        placeholder_text_len_cache: dict[str, int] = {}
+
         for param in reversed(param_info):
+            # Cache placeholder text length to avoid recalculation
+            if param.placeholder_text not in placeholder_text_len_cache:
+                placeholder_text_len_cache[param.placeholder_text] = len(param.placeholder_text)
+            text_len = placeholder_text_len_cache[param.placeholder_text]
+
             # Generate new placeholder based on target style
             if target_style in {
                 ParameterStyle.QMARK,
@@ -594,23 +621,19 @@ def _convert_placeholders_to_style(
                 ParameterStyle.POSITIONAL_PYFORMAT,
                 ParameterStyle.POSITIONAL_COLON,
             }:
-                # Use the appropriate key for the unique parameter mapping
-                if use_sequential_for_qmark and param.style == ParameterStyle.QMARK:
-                    param_key = f"{param.placeholder_text}_{param.ordinal}"
-                else:
-                    param_key = param.placeholder_text
-
-                ordinal_to_use = unique_params[param_key]
-                new_placeholder = generator(ordinal_to_use)
+                param_key = (
+                    f"{param.placeholder_text}_{param.ordinal}"
+                    if use_sequential_for_qmark and param.style == ParameterStyle.QMARK
+                    else param.placeholder_text
+                )
+                new_placeholder = generator(unique_params[param_key])
             else:  # Named styles
                 param_name = param.name or f"param_{param.ordinal}"
                 new_placeholder = generator(param_name)
 
-            # Replace in SQL
+            # Optimized string replacement
             converted_sql = (
-                converted_sql[: param.position]
-                + new_placeholder
-                + converted_sql[param.position + len(param.placeholder_text) :]
+                converted_sql[: param.position] + new_placeholder + converted_sql[param.position + text_len :]
             )
 
         return converted_sql
@@ -1116,9 +1139,14 @@ def _determine_target_execution_style(
     def _apply_type_wrapping(self, parameters: Any) -> Any:
         """Apply type wrapping using singledispatch for performance."""
         if isinstance(parameters, Sequence) and not isinstance(parameters, (str, bytes)):
+            # Optimize with direct iteration instead of list comprehension for better memory usage
             return [_wrap_parameter_by_type(p) for p in parameters]
         if isinstance(parameters, Mapping):
-            return {k: _wrap_parameter_by_type(v) for k, v in parameters.items()}
+            # Optimize dict comprehension with items() iteration
+            wrapped_dict = {}
+            for k, v in parameters.items():
+                wrapped_dict[k] = _wrap_parameter_by_type(v)
+            return wrapped_dict
         return _wrap_parameter_by_type(parameters)
 
     def _apply_type_coercions(
diff --git a/sqlspec/core/result.py b/sqlspec/core/result.py
index 1250a9788..892cf491f 100644
--- a/sqlspec/core/result.py
+++ b/sqlspec/core/result.py
@@ -188,19 +188,22 @@ def __init__(
         self._operation_type = operation_type
         self.operation_index = operation_index
         self.parameters = parameters
-        self.column_names = column_names if column_names is not None else []
+
+        # Optimize list initialization to avoid unnecessary object creation
+        self.column_names = column_names or []
         self.total_count = total_count
         self.has_more = has_more
-        self.inserted_ids = inserted_ids if inserted_ids is not None else []
-        self.statement_results: list[SQLResult] = statement_results if statement_results is not None else []
-        self.errors = errors if errors is not None else []
+        self.inserted_ids = inserted_ids or []
+        self.statement_results = statement_results or []
+        self.errors = errors or []
         self.total_statements = total_statements
         self.successful_statements = successful_statements
 
-        if not self.column_names and self.data is not None and self.data:
-            self.column_names = list(self.data[0].keys())
+        # Optimize column name extraction and count calculation
+        if not self.column_names and data and len(data) > 0:
+            self.column_names = list(data[0].keys())
         if self.total_count is None:
-            self.total_count = len(self.data) if self.data is not None else 0
+            self.total_count = len(data) if data is not None else 0
 
     @property
     def operation_type(self) -> "OperationType":
@@ -256,18 +259,21 @@ def get_data(self) -> "list[dict[str,Any]]":
         Returns:
             List of result rows or script summary.
         """
-        if self.operation_type.upper() == "SCRIPT":
+        op_type_upper = self.operation_type.upper()
+        if op_type_upper == "SCRIPT":
+            # Cache calculation to avoid redundant work
+            failed_statements = self.total_statements - self.successful_statements
             return [
                 {
                     "total_statements": self.total_statements,
                     "successful_statements": self.successful_statements,
-                    "failed_statements": self.total_statements - self.successful_statements,
+                    "failed_statements": failed_statements,
                     "errors": self.errors,
                     "statement_results": self.statement_results,
                     "total_rows_affected": self.get_total_rows_affected(),
                 }
             ]
-        return self.data if self.data is not None else []
+        return self.data or []
 
     def add_statement_result(self, result: "SQLResult") -> None:
         """Add a statement result to the script execution results.
@@ -287,9 +293,11 @@ def get_total_rows_affected(self) -> int:
             Total rows affected.
         """
         if self.statement_results:
-            return sum(
-                stmt.rows_affected for stmt in self.statement_results if stmt.rows_affected and stmt.rows_affected > 0
-            )
+            total = 0
+            for stmt in self.statement_results:
+                if stmt.rows_affected and stmt.rows_affected > 0:
+                    total += stmt.rows_affected
+            return total
         return self.rows_affected if self.rows_affected and self.rows_affected > 0 else 0
 
     @property
@@ -394,9 +402,7 @@ def __iter__(self) -> "Iterator[dict[str, Any]]":
         Returns:
             Iterator that yields each row as a dictionary
         """
-        if self.data is None:
-            return iter([])
-        return iter(self.data)
+        return iter(self.data or [])
 
     def all(self) -> list[dict[str, Any]]:
         """Return all rows as a list.
@@ -415,14 +421,18 @@ def one(self) -> "dict[str, Any]":
         Raises:
             ValueError: If no results or more than one result
         """
-        data_len = 0 if self.data is None else len(self.data)
+        if not self.data:
+            msg = "No result found, exactly one row expected"
+            raise ValueError(msg)
 
+        data_len = len(self.data)
         if data_len == 0:
             msg = "No result found, exactly one row expected"
             raise ValueError(msg)
         if data_len > 1:
             msg = f"Multiple results found ({data_len}), exactly one row expected"
             raise ValueError(msg)
+
         return cast("dict[str, Any]", self.data[0])
 
     def one_or_none(self) -> "Optional[dict[str, Any]]":
@@ -438,9 +448,12 @@ def one_or_none(self) -> "Optional[dict[str, Any]]":
             return None
 
         data_len = len(self.data)
+        if data_len == 0:
+            return None
         if data_len > 1:
             msg = f"Multiple results found ({data_len}), at most one row expected"
             raise ValueError(msg)
+
         return cast("dict[str, Any]", self.data[0])
 
     def scalar(self) -> Any:
diff --git a/sqlspec/core/statement.py b/sqlspec/core/statement.py
index b12217b50..615dff228 100644
--- a/sqlspec/core/statement.py
+++ b/sqlspec/core/statement.py
@@ -220,13 +220,20 @@ def _process_parameters(self, *parameters: Any, dialect: Optional[str] = None, *
         if "is_script" in kwargs:
             self._is_script = bool(kwargs.pop("is_script"))
 
-        filters = [p for p in parameters if is_statement_filter(p)]
-        actual_params = [p for p in parameters if not is_statement_filter(p)]
+        # Optimize parameter filtering with direct iteration
+        filters: list[StatementFilter] = []
+        actual_params: list[Any] = []
+        for p in parameters:
+            if is_statement_filter(p):
+                filters.append(p)
+            else:
+                actual_params.append(p)
 
         self._filters.extend(filters)
 
         if actual_params:
-            if len(actual_params) == 1:
+            param_count = len(actual_params)
+            if param_count == 1:
                 param = actual_params[0]
                 if isinstance(param, dict):
                     self._named_parameters.update(param)
@@ -339,10 +346,11 @@ def compile(self) -> tuple[str, Any]:
         """Explicitly compile the SQL statement."""
         if self._processed_state is Empty:
             try:
-                current_parameters = self._named_parameters or self._positional_parameters
+                # Avoid unnecessary variable assignment
                 processor = SQLProcessor(self._statement_config)
-
-                compiled_result = processor.compile(self._raw_sql, current_parameters, is_many=self._is_many)
+                compiled_result = processor.compile(
+                    self._raw_sql, self._named_parameters or self._positional_parameters, is_many=self._is_many
+                )
 
                 self._processed_state = ProcessedState(
                     compiled_sql=compiled_result.compiled_sql,
@@ -421,6 +429,7 @@ def where(self, condition: "Union[str, exp.Expression]") -> "SQL":
         Returns:
             New SQL instance with the WHERE condition applied
         """
+        # Parse current SQL with copy=False optimization
         current_expr = None
         with contextlib.suppress(ParseError):
             current_expr = sqlglot.parse_one(self._raw_sql, dialect=self._dialect)
@@ -429,8 +438,11 @@ def where(self, condition: "Union[str, exp.Expression]") -> "SQL":
             try:
                 current_expr = sqlglot.parse_one(self._raw_sql, dialect=self._dialect)
             except ParseError:
-                current_expr = sqlglot.parse_one(f"SELECT * FROM ({self._raw_sql}) AS subquery", dialect=self._dialect)
+                # Use f-string optimization and copy=False
+                subquery_sql = f"SELECT * FROM ({self._raw_sql}) AS subquery"
+                current_expr = sqlglot.parse_one(subquery_sql, dialect=self._dialect)
 
+        # Parse condition with copy=False optimization
         condition_expr: exp.Expression
         if isinstance(condition, str):
             try:
@@ -440,34 +452,32 @@ def where(self, condition: "Union[str, exp.Expression]") -> "SQL":
         else:
             condition_expr = condition
 
+        # Apply WHERE clause
         if isinstance(current_expr, exp.Select) or supports_where(current_expr):
-            new_expr = current_expr.where(condition_expr)
+            new_expr = current_expr.where(condition_expr, copy=False)
         else:
-            new_expr = exp.Select().from_(current_expr).where(condition_expr)
+            new_expr = exp.Select().from_(current_expr).where(condition_expr, copy=False)
 
+        # Generate SQL and create new instance
         new_sql_text = new_expr.sql(dialect=self._dialect)
-
         new_sql = SQL(
             new_sql_text, *self._original_parameters, statement_config=self._statement_config, is_many=self._is_many
         )
-        # Preserve accumulated named parameters when creating WHERE clause
+
+        # Preserve state efficiently
         new_sql._named_parameters.update(self._named_parameters)
         new_sql._positional_parameters = self._positional_parameters.copy()
         new_sql._filters = self._filters.copy()
         return new_sql
 
     def __hash__(self) -> int:
-        """Hash value."""
+        """Hash value with optimized computation."""
         if self._hash is None:
-            self._hash = hash(
-                (
-                    self._raw_sql,
-                    tuple(self._positional_parameters),
-                    tuple(sorted(self._named_parameters.items())),
-                    self._is_many,
-                    self._is_script,
-                )
-            )
+            # Pre-compute tuple components to avoid multiple tuple() calls
+            positional_tuple = tuple(self._positional_parameters)
+            named_tuple = tuple(sorted(self._named_parameters.items())) if self._named_parameters else ()
+
+            self._hash = hash((self._raw_sql, positional_tuple, named_tuple, self._is_many, self._is_script))
         return self._hash
 
     def __eq__(self, other: object) -> bool:
diff --git a/sqlspec/driver/_async.py b/sqlspec/driver/_async.py
index 56bd15c22..307a1517d 100644
--- a/sqlspec/driver/_async.py
+++ b/sqlspec/driver/_async.py
@@ -5,7 +5,7 @@
 """
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Final, NoReturn, Optional, Union, cast, overload
 
 from sqlspec.core import SQL, Statement
 from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult
@@ -20,14 +20,15 @@
 
     from sqlspec.builder import QueryBuilder
     from sqlspec.core import SQLResult, StatementConfig, StatementFilter
-    from sqlspec.typing import ModelDTOT, ModelT, RowT, StatementParameters
+    from sqlspec.typing import ModelDTOT, StatementParameters
 
-logger = get_logger("sqlspec")
+_LOGGER_NAME: Final[str] = "sqlspec"
+logger = get_logger(_LOGGER_NAME)
 
 __all__ = ("AsyncDriverAdapterBase",)
 
 
-EMPTY_FILTERS: "list[StatementFilter]" = []
+EMPTY_FILTERS: Final["list[StatementFilter]"] = []
 
 
 class AsyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToSchemaMixin):
@@ -128,12 +129,16 @@ async def _execute_script(self, cursor: Any, statement: "SQL") -> ExecutionResul
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statements = self.split_script_statements(sql, self.statement_config, strip_trailing_semicolon=True)
 
+        statement_count: int = len(statements)
+        successful_count: int = 0
+
         for stmt in statements:
             single_stmt = statement.copy(statement=stmt, parameters=prepared_parameters)
             await self._execute_statement(cursor, single_stmt)
+            successful_count += 1
 
         return self.create_execution_result(
-            cursor, statement_count=len(statements), successful_statements=len(statements), is_script_result=True
+            cursor, statement_count=statement_count, successful_statements=successful_count, is_script_result=True
         )
 
     @abstractmethod
@@ -214,8 +219,8 @@ async def execute_script(
         By default, validates each statement and logs warnings for dangerous
         operations. Use suppress_warnings=True for migrations and admin scripts.
         """
-        script_config = statement_config or self.statement_config
-        sql_statement = self.prepare_statement(statement, parameters, statement_config=script_config, kwargs=kwargs)
+        config = statement_config or self.statement_config
+        sql_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
 
         return await self.dispatch_statement_execution(statement=sql_statement.as_script(), connection=self.connection)
 
@@ -239,7 +244,7 @@ async def select_one(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT, dict[str, Any]]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "dict[str, Any]": ...
 
     async def select_one(
         self,
@@ -249,23 +254,20 @@ async def select_one(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT,ModelDTOT]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[dict[str, Any], ModelDTOT]":
         """Execute a select statement and return exactly one row.
 
         Raises an exception if no rows or more than one row is returned.
         """
         result = await self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
-            msg = "No rows found"
-            raise NotFoundError(msg)
-        if len(data) > 1:
-            msg = f"Expected exactly one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast(
-            "Union[ModelT, RowT, ModelDTOT]",
-            self.to_schema(data[0], schema_type=schema_type) if schema_type else data[0],
-        )
+        data_len: int = len(data)
+        if data_len == 0:
+            self._raise_no_rows_found()
+        if data_len > 1:
+            self._raise_expected_one_row(data_len)
+        first_row = data[0]
+        return self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row
 
     @overload
     async def select_one_or_none(
@@ -287,7 +289,7 @@ async def select_one_or_none(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[dict[str, Any]]": ...
 
     async def select_one_or_none(
         self,
@@ -297,7 +299,7 @@ async def select_one_or_none(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[Union[ModelT, ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
         """Execute a select statement and return at most one row.
 
         Returns None if no rows are found.
@@ -305,12 +307,16 @@ async def select_one_or_none(
         """
         result = await self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast("Optional[Union[ModelT, ModelDTOT]]", self.to_schema(data[0], schema_type=schema_type))
+        if data_len > 1:
+            self._raise_expected_at_most_one_row(data_len)
+        first_row = data[0]
+        return cast(
+            "Optional[Union[dict[str, Any], ModelDTOT]]",
+            self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row,
+        )
 
     @overload
     async def select(
@@ -332,7 +338,8 @@ async def select(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "list[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "list[dict[str, Any]]": ...
+
     async def select(
         self,
         statement: "Union[Statement, QueryBuilder]",
@@ -341,12 +348,11 @@ async def select(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[list[ModelT], list[ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[list[dict[str, Any]], list[ModelDTOT]]":
         """Execute a select statement and return all rows."""
         result = await self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         return cast(
-            "Union[list[ModelT], list[ModelDTOT]]",
-            self.to_schema(cast("list[ModelT]", result.get_data()), schema_type=schema_type),
+            "Union[list[dict[str, Any]], list[ModelDTOT]]", self.to_schema(result.get_data(), schema_type=schema_type)
         )
 
     async def select_value(
@@ -366,23 +372,19 @@ async def select_value(
         try:
             row = result.one()
         except ValueError as e:
-            msg = "No rows found"
-            raise NotFoundError(msg) from e
+            self._raise_no_rows_found_from_exception(e)
         if not row:
-            msg = "No rows found"
-            raise NotFoundError(msg)
+            self._raise_no_rows_found()
         if is_dict_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return next(iter(row.values()))
         if is_indexable_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return row[0]
-        msg = f"Unexpected row type: {type(row)}"
-        raise ValueError(msg)
+        self._raise_unexpected_row_type(type(row))
+        return None
 
     async def select_value_or_none(
         self,
@@ -400,11 +402,11 @@ async def select_value_or_none(
         """
         result = await self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
-            raise ValueError(msg)
+        if data_len > 1:
+            self._raise_expected_at_most_one_row(data_len)
         row = data[0]
         if is_dict_row(row):
             if not row:
@@ -412,8 +414,8 @@ async def select_value_or_none(
             return next(iter(row.values()))
         if is_indexable_row(row):
             return row[0]
-        msg = f"Cannot extract value from row type {type(row).__name__}"
-        raise TypeError(msg)
+        self._raise_cannot_extract_value_from_row_type(type(row).__name__)
+        return None
 
     @overload
     async def select_with_total(
@@ -470,3 +472,31 @@ async def select_with_total(
         select_result = await self.execute(sql_statement)
 
         return (self.to_schema(select_result.get_data(), schema_type=schema_type), count_result.scalar())
+
+    def _raise_no_rows_found(self) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg)
+
+    def _raise_no_rows_found_from_exception(self, e: ValueError) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg) from e
+
+    def _raise_expected_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected exactly one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_expected_at_most_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected at most one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_row_no_columns(self) -> NoReturn:
+        msg = "Row has no columns"
+        raise ValueError(msg)
+
+    def _raise_unexpected_row_type(self, row_type: type) -> NoReturn:
+        msg = f"Unexpected row type: {row_type}"
+        raise ValueError(msg)
+
+    def _raise_cannot_extract_value_from_row_type(self, type_name: str) -> NoReturn:
+        msg = f"Cannot extract value from row type {type_name}"
+        raise TypeError(msg)
diff --git a/sqlspec/driver/_common.py b/sqlspec/driver/_common.py
index b934806eb..403b20794 100644
--- a/sqlspec/driver/_common.py
+++ b/sqlspec/driver/_common.py
@@ -17,7 +17,9 @@
 from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
-    from sqlspec.core.filters import StatementFilter
+    from collections.abc import Sequence
+
+    from sqlspec.core.filters import FilterTypeT, StatementFilter
     from sqlspec.typing import StatementParameters
 
 
@@ -424,10 +426,9 @@ def apply_type_coercion(value: Any) -> Any:
         if isinstance(parameters, dict):
             if not parameters:
                 return []
-            if (
-                statement_config.parameter_config.supported_execution_parameter_styles
-                and ParameterStyle.NAMED_PYFORMAT
-                in statement_config.parameter_config.supported_execution_parameter_styles
+            if statement_config.parameter_config.supported_execution_parameter_styles and (
+                ParameterStyle.NAMED_PYFORMAT in statement_config.parameter_config.supported_execution_parameter_styles
+                or ParameterStyle.NAMED_COLON in statement_config.parameter_config.supported_execution_parameter_styles
             ):
                 return {k: apply_type_coercion(v) for k, v in parameters.items()}
             if statement_config.parameter_config.default_parameter_style in {
@@ -577,6 +578,24 @@ def _get_dominant_parameter_style(self, parameters: "list[Any]") -> "Optional[Pa
 
         return max(style_counts.keys(), key=lambda style: (style_counts[style], -precedence.get(style, 99)))
 
+    @staticmethod
+    def find_filter(
+        filter_type: "type[FilterTypeT]",
+        filters: "Sequence[StatementFilter | StatementParameters] | Sequence[StatementFilter]",
+    ) -> "FilterTypeT | None":
+        """Get the filter specified by filter type from the filters.
+
+        Args:
+            filter_type: The type of filter to find.
+            filters: filter types to apply to the query
+
+        Returns:
+            The match filter instance or None
+        """
+        return next(
+            (cast("FilterTypeT | None", filter_) for filter_ in filters if isinstance(filter_, filter_type)), None
+        )
+
     def _create_count_query(self, original_sql: "SQL") -> "SQL":
         """Create a COUNT query from the original SQL statement.
 
@@ -586,7 +605,7 @@ def _create_count_query(self, original_sql: "SQL") -> "SQL":
         if not original_sql.expression:
             msg = "Cannot create COUNT query from empty SQL expression"
             raise ImproperConfigurationError(msg)
-        expr = original_sql.expression.copy()
+        expr = original_sql.expression
 
         if isinstance(expr, exp.Select):
             if expr.args.get("group"):
diff --git a/sqlspec/driver/_sync.py b/sqlspec/driver/_sync.py
index e50dd6c42..b7888e379 100644
--- a/sqlspec/driver/_sync.py
+++ b/sqlspec/driver/_sync.py
@@ -5,7 +5,7 @@
 """
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Final, NoReturn, Optional, Union, cast, overload
 
 from sqlspec.core import SQL
 from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult
@@ -20,14 +20,15 @@
 
     from sqlspec.builder import QueryBuilder
     from sqlspec.core import SQLResult, Statement, StatementConfig, StatementFilter
-    from sqlspec.typing import ModelDTOT, ModelT, RowT, StatementParameters
+    from sqlspec.typing import ModelDTOT, StatementParameters
 
-logger = get_logger("sqlspec")
+_LOGGER_NAME: Final[str] = "sqlspec"
+logger = get_logger(_LOGGER_NAME)
 
 __all__ = ("SyncDriverAdapterBase",)
 
 
-EMPTY_FILTERS: "list[StatementFilter]" = []
+EMPTY_FILTERS: Final["list[StatementFilter]"] = []
 
 
 class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToSchemaMixin):
@@ -128,12 +129,16 @@ def _execute_script(self, cursor: Any, statement: "SQL") -> ExecutionResult:
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statements = self.split_script_statements(sql, self.statement_config, strip_trailing_semicolon=True)
 
+        statement_count: int = len(statements)
+        successful_count: int = 0
+
         for stmt in statements:
             single_stmt = statement.copy(statement=stmt, parameters=prepared_parameters)
             self._execute_statement(cursor, single_stmt)
+            successful_count += 1
 
         return self.create_execution_result(
-            cursor, statement_count=len(statements), successful_statements=len(statements), is_script_result=True
+            cursor, statement_count=statement_count, successful_statements=successful_count, is_script_result=True
         )
 
     @abstractmethod
@@ -214,8 +219,8 @@ def execute_script(
         By default, validates each statement and logs warnings for dangerous
         operations. Use suppress_warnings=True for migrations and admin scripts.
         """
-        script_config = statement_config or self.statement_config
-        sql_statement = self.prepare_statement(statement, parameters, statement_config=script_config, kwargs=kwargs)
+        config = statement_config or self.statement_config
+        sql_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
 
         return self.dispatch_statement_execution(statement=sql_statement.as_script(), connection=self.connection)
 
@@ -239,7 +244,7 @@ def select_one(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT, dict[str, Any]]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "dict[str, Any]": ...
 
     def select_one(
         self,
@@ -249,23 +254,20 @@ def select_one(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT, ModelDTOT]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[dict[str, Any], ModelDTOT]":
         """Execute a select statement and return exactly one row.
 
         Raises an exception if no rows or more than one row is returned.
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
-            msg = "No rows found"
-            raise NotFoundError(msg)
-        if len(data) > 1:
-            msg = f"Expected exactly one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast(
-            "Union[ModelT, RowT, ModelDTOT]",
-            self.to_schema(data[0], schema_type=schema_type) if schema_type else data[0],
-        )
+        data_len: int = len(data)
+        if data_len == 0:
+            self._raise_no_rows_found()
+        if data_len > 1:
+            self._raise_expected_one_row(data_len)
+        first_row = data[0]
+        return self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row
 
     @overload
     def select_one_or_none(
@@ -287,7 +289,7 @@ def select_one_or_none(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[dict[str, Any]]": ...
 
     def select_one_or_none(
         self,
@@ -297,7 +299,7 @@ def select_one_or_none(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[Union[ModelT, ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
         """Execute a select statement and return at most one row.
 
         Returns None if no rows are found.
@@ -305,12 +307,16 @@ def select_one_or_none(
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast("Optional[Union[ModelT, ModelDTOT]]", self.to_schema(data[0], schema_type=schema_type))
+        if data_len > 1:
+            self._raise_expected_at_most_one_row(data_len)
+        first_row = data[0]
+        return cast(
+            "Optional[Union[dict[str, Any], ModelDTOT]]",
+            self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row,
+        )
 
     @overload
     def select(
@@ -332,7 +338,7 @@ def select(
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "list[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "list[dict[str, Any]]": ...
 
     def select(
         self,
@@ -342,12 +348,11 @@ def select(
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[list[ModelT], list[ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[list[dict[str, Any]], list[ModelDTOT]]":
         """Execute a select statement and return all rows."""
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         return cast(
-            "Union[list[ModelT], list[ModelDTOT]]",
-            self.to_schema(cast("list[ModelT]", result.get_data()), schema_type=schema_type),
+            "Union[list[dict[str, Any]], list[ModelDTOT]]", self.to_schema(result.get_data(), schema_type=schema_type)
         )
 
     def select_value(
@@ -367,23 +372,19 @@ def select_value(
         try:
             row = result.one()
         except ValueError as e:
-            msg = "No rows found"
-            raise NotFoundError(msg) from e
+            self._raise_no_rows_found_from_exception(e)
         if not row:
-            msg = "No rows found"
-            raise NotFoundError(msg)
+            self._raise_no_rows_found()
         if is_dict_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return next(iter(row.values()))
         if is_indexable_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return row[0]
-        msg = f"Unexpected row type: {type(row)}"
-        raise ValueError(msg)
+        self._raise_unexpected_row_type(type(row))
+        return None
 
     def select_value_or_none(
         self,
@@ -401,10 +402,11 @@ def select_value_or_none(
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
+        if data_len > 1:
+            msg = f"Expected at most one row, found {data_len}"
             raise ValueError(msg)
         row = data[0]
         if isinstance(row, dict):
@@ -471,3 +473,31 @@ def select_with_total(
         select_result = self.execute(sql_statement)
 
         return (self.to_schema(select_result.get_data(), schema_type=schema_type), count_result.scalar())
+
+    def _raise_no_rows_found(self) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg)
+
+    def _raise_no_rows_found_from_exception(self, e: ValueError) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg) from e
+
+    def _raise_expected_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected exactly one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_expected_at_most_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected at most one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_row_no_columns(self) -> NoReturn:
+        msg = "Row has no columns"
+        raise ValueError(msg)
+
+    def _raise_unexpected_row_type(self, row_type: type) -> NoReturn:
+        msg = f"Unexpected row type: {row_type}"
+        raise ValueError(msg)
+
+    def _raise_cannot_extract_value_from_row_type(self, type_name: str) -> NoReturn:
+        msg = f"Cannot extract value from row type {type_name}"
+        raise TypeError(msg)
diff --git a/sqlspec/driver/mixins/_result_tools.py b/sqlspec/driver/mixins/_result_tools.py
index 34476242d..e22c3692c 100644
--- a/sqlspec/driver/mixins/_result_tools.py
+++ b/sqlspec/driver/mixins/_result_tools.py
@@ -5,12 +5,12 @@
 from enum import Enum
 from functools import partial
 from pathlib import Path, PurePath
-from typing import Any, Callable, Optional, overload
+from typing import Any, Callable, Final, Optional, overload
 from uuid import UUID
 
 from mypy_extensions import trait
 
-from sqlspec.exceptions import SQLSpecError, wrap_exceptions
+from sqlspec.exceptions import SQLSpecError
 from sqlspec.typing import (
     CATTRS_INSTALLED,
     ModelDTOT,
@@ -27,7 +27,12 @@
 
 
 logger = logging.getLogger(__name__)
-_DEFAULT_TYPE_DECODERS: list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]] = [
+
+# Constants for performance optimization
+_DATETIME_TYPES: Final[set[type]] = {datetime.datetime, datetime.date, datetime.time}
+_PATH_TYPES: Final[tuple[type, ...]] = (Path, PurePath, UUID)
+
+_DEFAULT_TYPE_DECODERS: Final[list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]]] = [
     (lambda x: x is UUID, lambda t, v: t(v.hex)),
     (lambda x: x is datetime.datetime, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.date, lambda t, v: t(v.isoformat())),
@@ -48,17 +53,32 @@ def _default_msgspec_deserializer(
         for predicate, decoder in type_decoders:
             if predicate(target_type):
                 return decoder(target_type, value)
+
+    # Fast path checks using type identity and isinstance
     if target_type is UUID and isinstance(value, UUID):
         return value.hex
-    if target_type in {datetime.datetime, datetime.date, datetime.time}:
-        with wrap_exceptions(suppress=AttributeError):
+
+    # Use pre-computed set for faster lookup
+    if target_type in _DATETIME_TYPES:
+        try:
             return value.isoformat()
+        except AttributeError:
+            pass
+
     if isinstance(target_type, type) and issubclass(target_type, Enum) and isinstance(value, Enum):
         return value.value
+
     if isinstance(value, target_type):
         return value
-    if issubclass(target_type, (Path, PurePath, UUID)):
-        return target_type(value)
+
+    # Check for path types using pre-computed tuple
+    if isinstance(target_type, type):
+        try:
+            if issubclass(target_type, (Path, PurePath)) or issubclass(target_type, UUID):
+                return target_type(str(value))
+        except (TypeError, ValueError):
+            pass
+
     return value
 
 
@@ -119,46 +139,55 @@ def to_schema(data: Any, *, schema_type: "Optional[type[ModelDTOT]]" = None) ->
             return data
         if is_dataclass(schema_type):
             if isinstance(data, list):
-                return [schema_type(**dict(item) if hasattr(item, "keys") else item) for item in data]  # type: ignore[operator]
+                result: list[Any] = []
+                for item in data:
+                    if hasattr(item, "keys"):
+                        result.append(schema_type(**dict(item)))  # type: ignore[operator]
+                    else:
+                        result.append(item)
+                return result
             if hasattr(data, "keys"):
                 return schema_type(**dict(data))  # type: ignore[operator]
             if isinstance(data, dict):
                 return schema_type(**data)  # type: ignore[operator]
-            # Fallback for other types
             return data
         if is_msgspec_struct(schema_type):
+            # Cache the deserializer to avoid repeated partial() calls
+            deserializer = partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS)
             if not isinstance(data, Sequence):
-                return convert(
-                    obj=data,
-                    type=schema_type,
-                    from_attributes=True,
-                    dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-                )
+                return convert(obj=data, type=schema_type, from_attributes=True, dec_hook=deserializer)
             return convert(
                 obj=data,
                 type=list[schema_type],  # type: ignore[valid-type]  # pyright: ignore
                 from_attributes=True,
-                dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
+                dec_hook=deserializer,
             )
         if is_pydantic_model(schema_type):
             if not isinstance(data, Sequence):
-                return get_type_adapter(schema_type).validate_python(data, from_attributes=True)  # pyright: ignore
-            return get_type_adapter(list[schema_type]).validate_python(data, from_attributes=True)  # type: ignore[valid-type]  # pyright: ignore
+                adapter = get_type_adapter(schema_type)
+                return adapter.validate_python(data, from_attributes=True)  # pyright: ignore
+            list_adapter = get_type_adapter(list[schema_type])  # type: ignore[valid-type]  # pyright: ignore
+            return list_adapter.validate_python(data, from_attributes=True)
         if is_attrs_schema(schema_type):
             if CATTRS_INSTALLED:
                 if isinstance(data, Sequence):
                     return cattrs_structure(data, list[schema_type])  # type: ignore[valid-type]  # pyright: ignore
-                # If data is already structured (attrs instance), unstructure it first
                 if hasattr(data, "__attrs_attrs__"):
-                    data = cattrs_unstructure(data)
+                    unstructured_data = cattrs_unstructure(data)
+                    return cattrs_structure(unstructured_data, schema_type)  # pyright: ignore
                 return cattrs_structure(data, schema_type)  # pyright: ignore
             if isinstance(data, list):
-                return [schema_type(**dict(item) if hasattr(item, "keys") else attrs_asdict(item)) for item in data]
+                attrs_result: list[Any] = []
+                for item in data:
+                    if hasattr(item, "keys"):
+                        attrs_result.append(schema_type(**dict(item)))
+                    else:
+                        attrs_result.append(schema_type(**attrs_asdict(item)))
+                return attrs_result
             if hasattr(data, "keys"):
                 return schema_type(**dict(data))
             if isinstance(data, dict):
                 return schema_type(**data)
-            # Fallback for other types
             return data
         msg = "`schema_type` should be a valid Dataclass, Pydantic model, Msgspec struct, or Attrs class"
         raise SQLSpecError(msg)
diff --git a/sqlspec/driver/mixins/_sql_translator.py b/sqlspec/driver/mixins/_sql_translator.py
index 92a04e03d..a733864cc 100644
--- a/sqlspec/driver/mixins/_sql_translator.py
+++ b/sqlspec/driver/mixins/_sql_translator.py
@@ -1,3 +1,5 @@
+from typing import Final, NoReturn, Optional
+
 from mypy_extensions import trait
 from sqlglot import exp, parse_one
 from sqlglot.dialects.dialect import DialectType
@@ -7,6 +9,9 @@
 
 __all__ = ("SQLTranslatorMixin",)
 
+# Constants for better performance
+_DEFAULT_PRETTY: Final[bool] = True
+
 
 @trait
 class SQLTranslatorMixin:
@@ -14,23 +19,68 @@ class SQLTranslatorMixin:
 
     __slots__ = ()
 
-    def convert_to_dialect(self, statement: "Statement", to_dialect: DialectType = None, pretty: bool = True) -> str:
+    def convert_to_dialect(
+        self, statement: "Statement", to_dialect: "Optional[DialectType]" = None, pretty: bool = _DEFAULT_PRETTY
+    ) -> str:
+        """Convert a statement to a target SQL dialect.
+
+        Args:
+            statement: SQL statement to convert
+            to_dialect: Target dialect (defaults to current dialect)
+            pretty: Whether to format the output SQL
+
+        Returns:
+            SQL string in target dialect
+
+        Raises:
+            SQLConversionError: If parsing or conversion fails
+        """
+        # Fast path: get the parsed expression with minimal allocations
+        parsed_expression: Optional[exp.Expression] = None
+
         if statement is not None and isinstance(statement, SQL):
             if statement.expression is None:
-                msg = "Statement could not be parsed"
-                raise SQLConversionError(msg)
+                self._raise_statement_parse_error()
             parsed_expression = statement.expression
         elif isinstance(statement, exp.Expression):
             parsed_expression = statement
         else:
-            try:
-                parsed_expression = parse_one(statement, dialect=self.dialect)  # type: ignore[attr-defined]
-            except Exception as e:
-                error_msg = f"Failed to parse SQL statement: {e!s}"
-                raise SQLConversionError(error_msg) from e
+            parsed_expression = self._parse_statement_safely(statement)
+
+        # Get target dialect with fallback
         target_dialect = to_dialect or self.dialect  # type: ignore[attr-defined]
+
+        # Generate SQL with error handling
+        return self._generate_sql_safely(parsed_expression, target_dialect, pretty)
+
+    def _parse_statement_safely(self, statement: "Statement") -> "exp.Expression":
+        """Parse statement with copy=False optimization and proper error handling."""
+        try:
+            # Convert statement to string if needed
+            sql_string = str(statement)
+            # Use copy=False for better performance
+            return parse_one(sql_string, dialect=self.dialect, copy=False)  # type: ignore[attr-defined]
+        except Exception as e:
+            self._raise_parse_error(e)
+
+    def _generate_sql_safely(self, expression: "exp.Expression", dialect: DialectType, pretty: bool) -> str:
+        """Generate SQL with proper error handling."""
         try:
-            return parsed_expression.sql(dialect=target_dialect, pretty=pretty)
+            return expression.sql(dialect=dialect, pretty=pretty)
         except Exception as e:
-            error_msg = f"Failed to convert SQL expression to {target_dialect}: {e!s}"
-            raise SQLConversionError(error_msg) from e
+            self._raise_conversion_error(dialect, e)
+
+    def _raise_statement_parse_error(self) -> NoReturn:
+        """Raise error for unparsable statements."""
+        msg = "Statement could not be parsed"
+        raise SQLConversionError(msg)
+
+    def _raise_parse_error(self, e: Exception) -> NoReturn:
+        """Raise error for parsing failures."""
+        error_msg = f"Failed to parse SQL statement: {e!s}"
+        raise SQLConversionError(error_msg) from e
+
+    def _raise_conversion_error(self, dialect: DialectType, e: Exception) -> NoReturn:
+        """Raise error for conversion failures."""
+        error_msg = f"Failed to convert SQL expression to {dialect}: {e!s}"
+        raise SQLConversionError(error_msg) from e
diff --git a/sqlspec/protocols.py b/sqlspec/protocols.py
index 44b39d1c5..217ce7228 100644
--- a/sqlspec/protocols.py
+++ b/sqlspec/protocols.py
@@ -371,6 +371,9 @@ class SQLBuilderProtocol(Protocol):
     _expression: "Optional[exp.Expression]"
     _parameters: dict[str, Any]
     _parameter_counter: int
+    _columns: Any  # Optional attribute for some builders
+    _table: Any  # Optional attribute for some builders
+    _with_ctes: Any  # Optional attribute for some builders
     dialect: Any
     dialect_name: "Optional[str]"
 
@@ -383,6 +386,10 @@ def add_parameter(self, value: Any, name: "Optional[str]" = None) -> tuple[Any,
         """Add a parameter to the builder."""
         ...
 
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate a unique parameter name."""
+        ...
+
     def _parameterize_expression(self, expression: "exp.Expression") -> "exp.Expression":
         """Replace literal values in an expression with bound parameters."""
         ...
diff --git a/sqlspec/utils/type_guards.py b/sqlspec/utils/type_guards.py
index 9d134032a..82a6280e2 100644
--- a/sqlspec/utils/type_guards.py
+++ b/sqlspec/utils/type_guards.py
@@ -841,9 +841,13 @@ def has_sql_method(obj: Any) -> "TypeGuard[HasSQLMethodProtocol]":
 
 def has_query_builder_parameters(obj: Any) -> "TypeGuard[SQLBuilderProtocol]":
     """Check if an object is a query builder with parameters property."""
-    from sqlspec.protocols import SQLBuilderProtocol
-
-    return isinstance(obj, SQLBuilderProtocol)
+    return (
+        hasattr(obj, "build")
+        and callable(getattr(obj, "build", None))
+        and hasattr(obj, "parameters")
+        and hasattr(obj, "add_parameter")
+        and callable(getattr(obj, "add_parameter", None))
+    )
 
 
 def is_object_store_item(obj: Any) -> "TypeGuard[ObjectStoreItemProtocol]":
diff --git a/tests/unit/test_builder_parameter_naming.py b/tests/unit/test_builder_parameter_naming.py
index 1e8f3d6d1..5aa14e7e1 100644
--- a/tests/unit/test_builder_parameter_naming.py
+++ b/tests/unit/test_builder_parameter_naming.py
@@ -72,28 +72,19 @@ def test_insert_without_columns_uses_positional_names() -> None:
 
 
 def test_case_when_uses_descriptive_names() -> None:
-    """Test that CASE WHEN expressions use descriptive parameter names."""
-    query = (
-        sql.select("name")
-        .from_("users")
-        .case_()
-        .when("age > 65", "Senior")
-        .when("age > 18", "Adult")
-        .else_("Minor")
-        .end()
-    )
+    """Test that CASE WHEN expressions work correctly with new property syntax."""
+    case_expr = sql.case_.when("age > 65", "Senior").when("age > 18", "Adult").else_("Minor").end()
+    query = sql.select("name", case_expr).from_("users")
     stmt = query.build()
 
-    # Should use descriptive names for CASE values
-    param_keys = list(stmt.parameters.keys())
-    case_params = [key for key in param_keys if "case" in key]
-    assert len(case_params) >= 2  # At least when and else values
-
-    # Should contain the actual values
-    param_values = list(stmt.parameters.values())
-    assert "Senior" in param_values
-    assert "Adult" in param_values
-    assert "Minor" in param_values
+    # CASE expressions using sql.case_ create literal SQL rather than parameters
+    # This is the expected behavior for the new property syntax
+    assert "CASE" in stmt.sql
+    assert "Senior" in stmt.sql
+    assert "Adult" in stmt.sql
+    assert "Minor" in stmt.sql
+    assert "> 65" in stmt.sql
+    assert "> 18" in stmt.sql
 
 
 def test_complex_query_preserves_column_names() -> None:
diff --git a/tests/unit/test_core/test_filters.py b/tests/unit/test_core/test_filters.py
index 52e845e32..bdd4d5712 100644
--- a/tests/unit/test_core/test_filters.py
+++ b/tests/unit/test_core/test_filters.py
@@ -17,6 +17,7 @@
     apply_filter,
 )
 from sqlspec.core.statement import SQL
+from sqlspec.driver._common import CommonDriverAttributesMixin
 
 
 def test_before_after_filter_uses_column_based_parameters() -> None:
@@ -255,3 +256,99 @@ def test_filter_sql_generation_preserves_parameter_names() -> None:
     assert "status_in_1" in result.parameters
     assert result.parameters["status_in_0"] == "active"
     assert result.parameters["status_in_1"] == "pending"
+
+
+def test_find_filter_returns_matching_filter() -> None:
+    """Test that find_filter returns the first matching filter of the specified type."""
+    # Create a list of filters with different types
+    search_filter = SearchFilter("name", "john")
+    limit_filter = LimitOffsetFilter(10, 0)
+    in_filter = InCollectionFilter("status", ["active", "pending"])
+    order_filter = OrderByFilter("created_at", "desc")
+
+    filters = [search_filter, limit_filter, in_filter, order_filter]
+
+    # Test finding each type of filter
+    found_search = CommonDriverAttributesMixin.find_filter(SearchFilter, filters)
+    assert found_search is search_filter
+    assert found_search is not None
+    assert found_search.field_name == "name"
+    assert found_search.value == "john"
+
+    found_limit = CommonDriverAttributesMixin.find_filter(LimitOffsetFilter, filters)
+    assert found_limit is limit_filter
+    assert found_limit is not None
+    assert found_limit.limit == 10
+    assert found_limit.offset == 0
+
+    found_in = CommonDriverAttributesMixin.find_filter(InCollectionFilter, filters)
+    assert found_in is in_filter
+    assert found_in is not None
+    assert found_in.field_name == "status"
+    assert found_in.values == ["active", "pending"]
+
+    found_order = CommonDriverAttributesMixin.find_filter(OrderByFilter, filters)
+    assert found_order is order_filter
+    assert found_order is not None
+    assert found_order.field_name == "created_at"
+    assert found_order.sort_order == "desc"
+
+
+def test_find_filter_returns_none_when_not_found() -> None:
+    """Test that find_filter returns None when no matching filter is found."""
+    # Create a list of filters without BeforeAfterFilter
+    search_filter = SearchFilter("name", "john")
+    limit_filter = LimitOffsetFilter(10, 0)
+
+    filters = [search_filter, limit_filter]
+
+    # Try to find a filter type that doesn't exist in the list
+    found_filter = CommonDriverAttributesMixin.find_filter(BeforeAfterFilter, filters)
+    assert found_filter is None
+
+
+def test_find_filter_returns_first_match_when_multiple_exist() -> None:
+    """Test that find_filter returns the first matching filter when multiple of the same type exist."""
+    # Create multiple filters of the same type
+    filter1 = SearchFilter("name", "john")
+    filter2 = SearchFilter("email", "test@example.com")
+    other_filter = LimitOffsetFilter(10, 0)
+
+    filters = [filter1, other_filter, filter2]
+
+    # Should return the first matching filter
+    found_filter = CommonDriverAttributesMixin.find_filter(SearchFilter, filters)
+    assert found_filter is filter1
+    assert found_filter is not None
+    assert found_filter.field_name == "name"
+    assert found_filter.value == "john"
+
+
+def test_find_filter_with_empty_filters_list() -> None:
+    """Test that find_filter returns None when given an empty filters list."""
+    filters: list[object] = []
+
+    found_filter = CommonDriverAttributesMixin.find_filter(SearchFilter, filters)
+    assert found_filter is None
+
+
+def test_find_filter_with_mixed_parameter_types() -> None:
+    """Test that find_filter works with mixed filter and parameter types."""
+    # Test with a mixture of filters and other objects (simulating StatementParameters)
+    search_filter = SearchFilter("name", "john")
+    some_parameter = {"key": "value"}  # Simulating StatementParameters
+    limit_filter = LimitOffsetFilter(5, 10)
+
+    # Mixed list with different types
+    filters: list[object] = [search_filter, some_parameter, limit_filter]
+
+    # Should find the filter even with mixed types
+    found_search = CommonDriverAttributesMixin.find_filter(SearchFilter, filters)
+    assert found_search is search_filter
+
+    found_limit = CommonDriverAttributesMixin.find_filter(LimitOffsetFilter, filters)
+    assert found_limit is limit_filter
+
+    # Should return None for filter types not in the list
+    found_order = CommonDriverAttributesMixin.find_filter(OrderByFilter, filters)
+    assert found_order is None
diff --git a/tests/unit/test_sql_factory.py b/tests/unit/test_sql_factory.py
index 20fd7bbb2..6eb2c514a 100644
--- a/tests/unit/test_sql_factory.py
+++ b/tests/unit/test_sql_factory.py
@@ -191,6 +191,19 @@ def test_raw_without_parameters_backward_compatibility() -> None:
     assert not isinstance(expr, SQL)
 
 
+def test_raw_expression_in_insert_values() -> None:
+    """Test that raw expressions work properly in insert values."""
+    query = sql.insert("logs").values(message="Test", created_at=sql.raw("NOW()"))
+    stmt = query.build()
+
+    assert "INSERT INTO" in stmt.sql
+    assert "logs" in stmt.sql
+    assert "message" in stmt.parameters
+    assert stmt.parameters["message"] == "Test"
+    # The raw expression should be included directly, not as a parameter
+    assert "NOW()" in stmt.sql
+
+
 def test_raw_with_named_parameters_returns_sql_object() -> None:
     """Test that raw() with parameters returns SQL statement object."""
     stmt = sql.raw("name = :name_param", name_param="John")
@@ -282,6 +295,46 @@ def test_insert_method() -> None:
     assert "email" in stmt.parameters
 
 
+def test_insert_values_with_kwargs() -> None:
+    """Test Insert.values() method with keyword arguments."""
+    query = (
+        sql.insert("team_member")
+        .values(team_id=1, user_id=2, role="admin", joined_at=sql.raw("NOW()"))
+        .returning("id", "team_id", "user_id", "role", "is_owner", "joined_at")
+    )
+    stmt = query.build()
+
+    assert "INSERT INTO" in stmt.sql
+    assert "team_member" in stmt.sql
+    assert "RETURNING" in stmt.sql
+    assert "team_id" in stmt.parameters
+    assert "user_id" in stmt.parameters
+    assert "role" in stmt.parameters
+    assert stmt.parameters["team_id"] == 1
+    assert stmt.parameters["user_id"] == 2
+    assert stmt.parameters["role"] == "admin"
+
+
+def test_insert_values_mixed_args_error() -> None:
+    """Test Insert.values() raises error when mixing positional and keyword arguments."""
+    with pytest.raises(SQLBuilderError, match="Cannot mix positional values with keyword values"):
+        sql.insert("users").values("John", email="john@test.com")
+
+
+def test_insert_values_with_mapping() -> None:
+    """Test Insert.values() method with a mapping argument."""
+    data = {"name": "John", "email": "john@test.com"}
+    query = sql.insert("users").values(data)
+    stmt = query.build()
+
+    assert "INSERT INTO" in stmt.sql
+    assert "users" in stmt.sql
+    assert "name" in stmt.parameters
+    assert "email" in stmt.parameters
+    assert stmt.parameters["name"] == "John"
+    assert stmt.parameters["email"] == "john@test.com"
+
+
 def test_update_method() -> None:
     """Test sql.update() method."""
     query = sql.update("users").set({"name": "Jane"}).where_eq("id", 1)
@@ -460,3 +513,352 @@ def test_parameter_values_preserved_correctly() -> None:
     none_stmt = none_query.build()
     assert "none_col" in none_stmt.parameters
     assert none_stmt.parameters["none_col"] is None
+
+
+def test_case_expression_basic_syntax() -> None:
+    """Test basic CASE expression syntax using sql.case_."""
+    case_expr = sql.case_.when("status = 'active'", "Active").else_("Inactive").end()
+
+    query = sql.select("id", case_expr).from_("users")
+    stmt = query.build()
+
+    assert "CASE" in stmt.sql
+    assert "WHEN" in stmt.sql
+    assert "ELSE" in stmt.sql
+    assert "END" in stmt.sql
+    assert "Active" in stmt.sql
+    assert "Inactive" in stmt.sql
+
+
+def test_case_expression_with_alias() -> None:
+    """Test CASE expression with alias using as_() method."""
+    case_expr = sql.case_.when("status = 'active'", "Active").else_("Inactive").as_("status_display")
+
+    query = sql.select("id", case_expr).from_("users")
+    stmt = query.build()
+
+    assert "CASE" in stmt.sql
+    assert "status_display" in stmt.sql
+    assert "Active" in stmt.sql
+    assert "Inactive" in stmt.sql
+
+
+def test_case_property_syntax() -> None:
+    """Test new sql.case_ property syntax."""
+    case_expr = sql.case_.when("status = 'active'", "Active").else_("Inactive").end()
+
+    query = sql.select("id", case_expr).from_("users")
+    stmt = query.build()
+
+    assert "CASE" in stmt.sql
+    assert "WHEN" in stmt.sql
+    assert "ELSE" in stmt.sql
+    assert "END" in stmt.sql
+    assert "Active" in stmt.sql
+    assert "Inactive" in stmt.sql
+
+
+def test_case_property_with_alias() -> None:
+    """Test new sql.case_ property syntax with alias."""
+    case_expr = sql.case_.when("status = 'active'", "Active").else_("Inactive").as_("status_display")
+
+    query = sql.select("id", case_expr).from_("users")
+    stmt = query.build()
+
+    assert "CASE" in stmt.sql
+    assert "status_display" in stmt.sql
+    assert "Active" in stmt.sql
+    assert "Inactive" in stmt.sql
+
+
+def test_case_multiple_when_clauses() -> None:
+    """Test CASE expression with multiple WHEN clauses."""
+    case_expr = sql.case_.when("age < 18", "Minor").when("age < 65", "Adult").else_("Senior").end()
+
+    query = sql.select("name", case_expr).from_("users")
+    stmt = query.build()
+
+    assert "CASE" in stmt.sql
+    assert "Minor" in stmt.sql
+    assert "Adult" in stmt.sql
+    assert "Senior" in stmt.sql
+
+
+def test_case_expression_type_compatibility() -> None:
+    """Test that all CASE expression variants are compatible with select()."""
+    old_case = sql.case().when("x = 1", "one").end()
+    new_case = sql.case_.when("x = 2", "two").end()
+    aliased_case = sql.case_.when("x = 3", "three").as_("x_desc")
+
+    query = sql.select("id", old_case, new_case, aliased_case).from_("test")
+    stmt = query.build()
+
+    assert "SELECT" in stmt.sql
+    assert "CASE" in stmt.sql
+    assert "one" in stmt.sql
+    assert "two" in stmt.sql
+    assert "three" in stmt.sql
+    assert "x_desc" in stmt.sql
+
+
+def test_case_property_returns_case_builder() -> None:
+    """Test that sql.case_ returns a Case builder instance."""
+    from sqlspec._sql import Case
+
+    case_builder = sql.case_
+    assert isinstance(case_builder, Case)
+    assert hasattr(case_builder, "when")
+    assert hasattr(case_builder, "else_")
+    assert hasattr(case_builder, "end")
+    assert hasattr(case_builder, "as_")
+
+
+def test_window_function_shortcuts() -> None:
+    """Test window function shortcuts like sql.row_number_."""
+    from sqlspec._sql import WindowFunctionBuilder
+
+    # Test that shortcuts return WindowFunctionBuilder instances
+    assert isinstance(sql.row_number_, WindowFunctionBuilder)
+    assert isinstance(sql.rank_, WindowFunctionBuilder)
+    assert isinstance(sql.dense_rank_, WindowFunctionBuilder)
+
+
+def test_window_function_with_alias() -> None:
+    """Test window function with alias and partition/order."""
+    window_func = sql.row_number_.partition_by("department").order_by("salary").as_("row_num")
+
+    query = sql.select("name", window_func).from_("employees")
+    stmt = query.build()
+
+    assert "ROW_NUMBER()" in stmt.sql
+    assert "OVER" in stmt.sql
+    assert "PARTITION BY" in stmt.sql
+    assert "ORDER BY" in stmt.sql
+    assert "row_num" in stmt.sql
+
+
+def test_window_function_without_alias() -> None:
+    """Test window function without alias."""
+    window_func = sql.rank_.partition_by("department").order_by("salary").build()
+
+    query = sql.select("name", window_func).from_("employees")
+    stmt = query.build()
+
+    assert "RANK()" in stmt.sql
+    assert "OVER" in stmt.sql
+    assert "PARTITION BY" in stmt.sql
+    assert "ORDER BY" in stmt.sql
+
+
+def test_multiple_window_functions() -> None:
+    """Test multiple window functions in same query."""
+    row_num = sql.row_number_.partition_by("department").order_by("salary").as_("row_num")
+    rank_val = sql.rank_.partition_by("department").order_by("salary").as_("rank_val")
+
+    query = sql.select("name", row_num, rank_val).from_("employees")
+    stmt = query.build()
+
+    assert "ROW_NUMBER()" in stmt.sql
+    assert "RANK()" in stmt.sql
+    assert "row_num" in stmt.sql
+    assert "rank_val" in stmt.sql
+
+
+def test_window_function_multiple_partition_columns() -> None:
+    """Test window function with multiple partition and order columns."""
+    window_func = sql.dense_rank_.partition_by("department", "team").order_by("salary", "hire_date").build()
+
+    query = sql.select("name", window_func).from_("employees")
+    stmt = query.build()
+
+    assert "DENSE_RANK()" in stmt.sql
+    assert "PARTITION BY" in stmt.sql
+    assert "department" in stmt.sql
+    assert "team" in stmt.sql
+    assert "salary" in stmt.sql
+    assert "hire_date" in stmt.sql
+
+
+def test_normal_column_access_preserved() -> None:
+    """Test that normal column access still works after adding window functions."""
+    # This should still return a Column, not a WindowFunctionBuilder
+    from sqlspec.builder._column import Column
+
+    assert isinstance(sql.department, Column)
+    assert isinstance(sql.some_normal_column, Column)
+
+    # But these should return WindowFunctionBuilder
+    from sqlspec._sql import WindowFunctionBuilder
+
+    assert isinstance(sql.row_number_, WindowFunctionBuilder)
+    assert isinstance(sql.rank_, WindowFunctionBuilder)
+
+
+def test_subquery_builders() -> None:
+    """Test subquery builder shortcuts."""
+    from sqlspec._sql import SubqueryBuilder
+
+    # Test that shortcuts return SubqueryBuilder instances
+    assert isinstance(sql.exists_, SubqueryBuilder)
+    assert isinstance(sql.in_, SubqueryBuilder)
+    assert isinstance(sql.any_, SubqueryBuilder)
+    assert isinstance(sql.all_, SubqueryBuilder)
+
+
+def test_exists_subquery() -> None:
+    """Test EXISTS subquery functionality."""
+    subquery = sql.select("1").from_("orders").where_eq("user_id", "123")
+    exists_expr = sql.exists_(subquery)
+
+    query = sql.select("*").from_("users").where(exists_expr)
+    stmt = query.build()
+
+    assert "EXISTS" in stmt.sql
+    assert "SELECT" in stmt.sql
+    assert "orders" in stmt.sql
+    # Note: The subquery parameters are embedded in the SQL structure
+
+
+def test_in_subquery() -> None:
+    """Test IN subquery functionality."""
+    subquery = sql.select("category_id").from_("categories").where_eq("active", True)
+    in_expr = sql.in_(subquery)
+
+    # Test that the expression is created correctly
+    from sqlglot.expressions import In
+
+    assert isinstance(in_expr, In)
+
+
+def test_any_subquery() -> None:
+    """Test ANY subquery functionality."""
+    subquery = sql.select("salary").from_("employees").where_eq("department", "Engineering")
+    any_expr = sql.any_(subquery)
+
+    from sqlglot.expressions import Any
+
+    assert isinstance(any_expr, Any)
+
+
+def test_all_subquery() -> None:
+    """Test ALL subquery functionality."""
+    subquery = sql.select("salary").from_("employees").where_eq("department", "Sales")
+    all_expr = sql.all_(subquery)
+
+    from sqlglot.expressions import All
+
+    assert isinstance(all_expr, All)
+
+
+def test_join_builders() -> None:
+    """Test join builder shortcuts."""
+    from sqlspec._sql import JoinBuilder
+
+    # Test that shortcuts return JoinBuilder instances
+    assert isinstance(sql.left_join_, JoinBuilder)
+    assert isinstance(sql.inner_join_, JoinBuilder)
+    assert isinstance(sql.right_join_, JoinBuilder)
+    assert isinstance(sql.full_join_, JoinBuilder)
+    assert isinstance(sql.cross_join_, JoinBuilder)
+
+
+def test_left_join_builder() -> None:
+    """Test LEFT JOIN builder functionality."""
+    join_expr = sql.left_join_("posts").on("users.id = posts.user_id")
+
+    from sqlglot.expressions import Join
+
+    assert isinstance(join_expr, Join)
+
+    # Test in a complete query
+    query = sql.select("users.name", "posts.title").from_("users").join(join_expr)
+    stmt = query.build()
+
+    assert "LEFT JOIN" in stmt.sql
+    assert "posts" in stmt.sql
+    assert "users.id" in stmt.sql or "posts.user_id" in stmt.sql
+
+
+def test_inner_join_builder_with_alias() -> None:
+    """Test INNER JOIN builder with table alias."""
+    join_expr = sql.inner_join_("profiles", "p").on("users.id = p.user_id")
+
+    query = sql.select("users.name", "p.bio").from_("users").join(join_expr)
+    stmt = query.build()
+
+    assert "JOIN" in stmt.sql
+    assert "profiles" in stmt.sql or "p" in stmt.sql
+
+
+def test_right_join_builder() -> None:
+    """Test RIGHT JOIN builder functionality."""
+    join_expr = sql.right_join_("comments").on("posts.id = comments.post_id")
+
+    query = sql.select("posts.title", "comments.content").from_("posts").join(join_expr)
+    stmt = query.build()
+
+    assert "RIGHT JOIN" in stmt.sql
+    assert "comments" in stmt.sql
+
+
+def test_full_join_builder() -> None:
+    """Test FULL JOIN builder functionality."""
+    join_expr = sql.full_join_("archive").on("users.id = archive.user_id")
+
+    query = sql.select("users.name", "archive.data").from_("users").join(join_expr)
+    stmt = query.build()
+
+    assert "FULL" in stmt.sql
+    assert "JOIN" in stmt.sql
+    assert "archive" in stmt.sql
+
+
+def test_cross_join_builder() -> None:
+    """Test CROSS JOIN builder functionality."""
+    join_expr = sql.cross_join_("settings").on("1=1")  # ON condition ignored for CROSS JOIN
+
+    query = sql.select("users.name", "settings.value").from_("users").join(join_expr)
+    stmt = query.build()
+
+    assert "CROSS" in stmt.sql or "JOIN" in stmt.sql
+    assert "settings" in stmt.sql
+
+
+def test_multiple_join_builders() -> None:
+    """Test multiple join builders in same query."""
+    left_join = sql.left_join_("posts").on("users.id = posts.user_id")
+    inner_join = sql.inner_join_("categories").on("posts.category_id = categories.id")
+
+    query = sql.select("users.name", "posts.title", "categories.name").from_("users").join(left_join).join(inner_join)
+    stmt = query.build()
+
+    assert "LEFT JOIN" in stmt.sql
+    assert "JOIN" in stmt.sql
+    assert "posts" in stmt.sql
+    assert "categories" in stmt.sql
+
+
+def test_backward_compatibility_preserved() -> None:
+    """Test that all existing functionality still works with new builders."""
+    # Original join methods should still work
+    query1 = sql.select("u.name", "p.title").from_("users u").left_join("posts p", "u.id = p.user_id")
+    stmt1 = query1.build()
+    assert "LEFT JOIN" in stmt1.sql
+
+    # Original case syntax should still work
+    case_expr = sql.case().when("status = 'active'", "Active").else_("Inactive").end()
+    query2 = sql.select("name", case_expr).from_("users")
+    stmt2 = query2.build()
+    assert "CASE" in stmt2.sql
+
+    # New window functions work
+    window_func = sql.row_number_.partition_by("department").order_by("salary").build()
+    query3 = sql.select("name", window_func).from_("employees")
+    stmt3 = query3.build()
+    assert "ROW_NUMBER" in stmt3.sql
+
+    # Column access should still work
+    from sqlspec.builder._column import Column
+
+    assert isinstance(sql.users, Column)
+    assert isinstance(sql.posts, Column)
diff --git a/uv.lock b/uv.lock
index 5c21e55f7..743feb275 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2917,92 +2917,92 @@ wheels = [
 
 [[package]]
 name = "orjson"
-version = "3.11.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/3b/fd9ff8ff64ae3900f11554d5cfc835fb73e501e043c420ad32ec574fe27f/orjson-3.11.1.tar.gz", hash = "sha256:48d82770a5fd88778063604c566f9c7c71820270c9cc9338d25147cbf34afd96", size = 5393373, upload-time = "2025-07-25T14:33:52.898Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/8b/7dd88f416e2e5834fd9809d871f471aae7d12dfd83d4786166fa5a926601/orjson-3.11.1-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:92d771c492b64119456afb50f2dff3e03a2db8b5af0eba32c5932d306f970532", size = 241312, upload-time = "2025-07-25T14:31:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/5d/5bfc371bd010ffbec90e64338aa59abcb13ed94191112199048653ee2f34/orjson-3.11.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0085ef83a4141c2ed23bfec5fecbfdb1e95dd42fc8e8c76057bdeeec1608ea65", size = 132791, upload-time = "2025-07-25T14:31:55.547Z" },
-    { url = "https://files.pythonhosted.org/packages/48/e2/c07854a6bad71e4249345efadb686c0aff250073bdab8ba9be7626af6516/orjson-3.11.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5caf7f13f2e1b4e137060aed892d4541d07dabc3f29e6d891e2383c7ed483440", size = 128690, upload-time = "2025-07-25T14:31:56.708Z" },
-    { url = "https://files.pythonhosted.org/packages/48/e4/2e075348e7772aa1404d51d8df25ff4d6ee3daf682732cb21308e3b59c32/orjson-3.11.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f716bcc166524eddfcf9f13f8209ac19a7f27b05cf591e883419079d98c8c99d", size = 130646, upload-time = "2025-07-25T14:31:58.165Z" },
-    { url = "https://files.pythonhosted.org/packages/97/09/50daacd3ac7ae564186924c8d1121940f2c78c64d6804dbe81dd735ab087/orjson-3.11.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:507d6012fab05465d8bf21f5d7f4635ba4b6d60132874e349beff12fb51af7fe", size = 132620, upload-time = "2025-07-25T14:31:59.226Z" },
-    { url = "https://files.pythonhosted.org/packages/da/21/5f22093fa90e6d6fcf8111942b530a4ad19ee1cc0b06ddad4a63b16ab852/orjson-3.11.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1545083b0931f754c80fd2422a73d83bea7a6d1b6de104a5f2c8dd3d64c291e", size = 135121, upload-time = "2025-07-25T14:32:00.653Z" },
-    { url = "https://files.pythonhosted.org/packages/48/90/77ad4bfa6bd400a3d241695e3e39975e32fe027aea5cb0b171bd2080c427/orjson-3.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e217ce3bad76351e1eb29ebe5ca630326f45cd2141f62620107a229909501a3", size = 131131, upload-time = "2025-07-25T14:32:01.821Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/64/d383675229f7ffd971b6ec6cdd3016b00877bb6b2d5fc1fd099c2ec2ad57/orjson-3.11.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:06ef26e009304bda4df42e4afe518994cde6f89b4b04c0ff24021064f83f4fbb", size = 131025, upload-time = "2025-07-25T14:32:02.879Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/82/e4017d8d98597f6056afaf75021ff390154d1e2722c66ba45a4d50f82606/orjson-3.11.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:ba49683b87bea3ae1489a88e766e767d4f423a669a61270b6d6a7ead1c33bd65", size = 404464, upload-time = "2025-07-25T14:32:04.384Z" },
-    { url = "https://files.pythonhosted.org/packages/77/7e/45c7f813c30d386c0168a32ce703494262458af6b222a3eeac1c0bb88822/orjson-3.11.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5072488fcc5cbcda2ece966d248e43ea1d222e19dd4c56d3f82747777f24d864", size = 146416, upload-time = "2025-07-25T14:32:05.57Z" },
-    { url = "https://files.pythonhosted.org/packages/41/71/6ccb4d7875ec3349409960769a28349f477856f05de9fd961454c2b99230/orjson-3.11.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f58ae2bcd119226fe4aa934b5880fe57b8e97b69e51d5d91c88a89477a307016", size = 135497, upload-time = "2025-07-25T14:32:06.704Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/ce/df8dac7da075962fdbfca55d53e3601aa910c9f23606033bf0f084835720/orjson-3.11.1-cp310-cp310-win32.whl", hash = "sha256:6723be919c07906781b9c63cc52dc7d2fb101336c99dd7e85d3531d73fb493f7", size = 136807, upload-time = "2025-07-25T14:32:08.303Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/a0/f6c2be24709d1742d878b4530fa0c3f4a5e190d51397b680abbf44d11dbf/orjson-3.11.1-cp310-cp310-win_amd64.whl", hash = "sha256:5fd44d69ddfdfb4e8d0d83f09d27a4db34930fba153fbf79f8d4ae8b47914e04", size = 131561, upload-time = "2025-07-25T14:32:09.444Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/92/7ab270b5b3df8d5b0d3e572ddf2f03c9f6a79726338badf1ec8594e1469d/orjson-3.11.1-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:15e2a57ce3b57c1a36acffcc02e823afefceee0a532180c2568c62213c98e3ef", size = 240918, upload-time = "2025-07-25T14:32:11.021Z" },
-    { url = "https://files.pythonhosted.org/packages/80/41/df44684cfbd2e2e03bf9b09fdb14b7abcfff267998790b6acfb69ad435f0/orjson-3.11.1-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:17040a83ecaa130474af05bbb59a13cfeb2157d76385556041f945da936b1afd", size = 129386, upload-time = "2025-07-25T14:32:12.361Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/08/958f56edd18ba1827ad0c74b2b41a7ae0864718adee8ccb5d1a5528f8761/orjson-3.11.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a68f23f09e5626cc0867a96cf618f68b91acb4753d33a80bf16111fd7f9928c", size = 132508, upload-time = "2025-07-25T14:32:13.917Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/5e56e189dacbf51e53ba8150c20e61ee746f6d57b697f5c52315ffc88a83/orjson-3.11.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47e07528bb6ccbd6e32a55e330979048b59bfc5518b47c89bc7ab9e3de15174a", size = 128501, upload-time = "2025-07-25T14:32:15.13Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/de/f6c301a514f5934405fd4b8f3d3efc758c911d06c3de3f4be1e30d675fa4/orjson-3.11.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3807cce72bf40a9d251d689cbec28d2efd27e0f6673709f948f971afd52cb09", size = 130465, upload-time = "2025-07-25T14:32:17.355Z" },
-    { url = "https://files.pythonhosted.org/packages/47/08/f7dbaab87d6f05eebff2d7b8e6a8ed5f13b2fe3e3ae49472b527d03dbd7a/orjson-3.11.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b2dc7e88da4ca201c940f5e6127998d9e89aa64264292334dad62854bc7fc27", size = 132416, upload-time = "2025-07-25T14:32:18.933Z" },
-    { url = "https://files.pythonhosted.org/packages/43/3f/dd5a185273b7ba6aa238cfc67bf9edaa1885ae51ce942bc1a71d0f99f574/orjson-3.11.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3091dad33ac9e67c0a550cfff8ad5be156e2614d6f5d2a9247df0627751a1495", size = 134924, upload-time = "2025-07-25T14:32:20.134Z" },
-    { url = "https://files.pythonhosted.org/packages/db/ef/729d23510eaa81f0ce9d938d99d72dcf5e4ed3609d9d0bcf9c8a282cc41a/orjson-3.11.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ed0fce2307843b79a0c83de49f65b86197f1e2310de07af9db2a1a77a61ce4c", size = 130938, upload-time = "2025-07-25T14:32:21.769Z" },
-    { url = "https://files.pythonhosted.org/packages/82/96/120feb6807f9e1f4c68fc842a0f227db8575eafb1a41b2537567b91c19d8/orjson-3.11.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5a31e84782a18c30abd56774c0cfa7b9884589f4d37d9acabfa0504dad59bb9d", size = 130811, upload-time = "2025-07-25T14:32:22.931Z" },
-    { url = "https://files.pythonhosted.org/packages/89/66/4695e946a453fa22ff945da4b1ed0691b3f4ec86b828d398288db4a0ff79/orjson-3.11.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:26b6c821abf1ae515fbb8e140a2406c9f9004f3e52acb780b3dee9bfffddbd84", size = 404272, upload-time = "2025-07-25T14:32:25.238Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/7b/1c953e2c9e55af126c6cb678a30796deb46d7713abdeb706b8765929464c/orjson-3.11.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f857b3d134b36a8436f1e24dcb525b6b945108b30746c1b0b556200b5cb76d39", size = 146196, upload-time = "2025-07-25T14:32:26.909Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/c2/bef5d3bc83f2e178592ff317e2cf7bd38ebc16b641f076ea49f27aadd1d3/orjson-3.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:df146f2a14116ce80f7da669785fcb411406d8e80136558b0ecda4c924b9ac55", size = 135336, upload-time = "2025-07-25T14:32:28.22Z" },
-    { url = "https://files.pythonhosted.org/packages/92/95/bc6006881ebdb4608ed900a763c3e3c6be0d24c3aadd62beb774f9464ec6/orjson-3.11.1-cp311-cp311-win32.whl", hash = "sha256:d777c57c1f86855fe5492b973f1012be776e0398571f7cc3970e9a58ecf4dc17", size = 136665, upload-time = "2025-07-25T14:32:29.976Z" },
-    { url = "https://files.pythonhosted.org/packages/59/c3/1f2b9cc0c60ea2473d386fed2df2b25ece50aeb73c798d4669aadff3061e/orjson-3.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:e9a5fd589951f02ec2fcb8d69339258bbf74b41b104c556e6d4420ea5e059313", size = 131388, upload-time = "2025-07-25T14:32:31.595Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/e5/40c97e5a6b85944022fe54b463470045b8651b7bb2f1e16a95c42812bf97/orjson-3.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:4cddbe41ee04fddad35d75b9cf3e3736ad0b80588280766156b94783167777af", size = 126786, upload-time = "2025-07-25T14:32:32.787Z" },
-    { url = "https://files.pythonhosted.org/packages/98/77/e55513826b712807caadb2b733eee192c1df105c6bbf0d965c253b72f124/orjson-3.11.1-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:2b7c8be96db3a977367250c6367793a3c5851a6ca4263f92f0b48d00702f9910", size = 240955, upload-time = "2025-07-25T14:32:34.056Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/88/a78132dddcc9c3b80a9fa050b3516bb2c996a9d78ca6fb47c8da2a80a696/orjson-3.11.1-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:72e18088f567bd4a45db5e3196677d9ed1605e356e500c8e32dd6e303167a13d", size = 129294, upload-time = "2025-07-25T14:32:35.323Z" },
-    { url = "https://files.pythonhosted.org/packages/09/02/6591e0dcb2af6bceea96cb1b5f4b48c1445492a3ef2891ac4aa306bb6f73/orjson-3.11.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d346e2ae1ce17888f7040b65a5a4a0c9734cb20ffbd228728661e020b4c8b3a5", size = 132310, upload-time = "2025-07-25T14:32:36.53Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/36/c1cfbc617bcfa4835db275d5e0fe9bbdbe561a4b53d3b2de16540ec29c50/orjson-3.11.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4bda5426ebb02ceb806a7d7ec9ba9ee5e0c93fca62375151a7b1c00bc634d06b", size = 128529, upload-time = "2025-07-25T14:32:37.817Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/bd/91a156c5df3aaf1d68b2ab5be06f1969955a8d3e328d7794f4338ac1d017/orjson-3.11.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10506cebe908542c4f024861102673db534fd2e03eb9b95b30d94438fa220abf", size = 130925, upload-time = "2025-07-25T14:32:39.03Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/4c/a65cc24e9a5f87c9833a50161ab97b5edbec98bec99dfbba13827549debc/orjson-3.11.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:45202ee3f5494644e064c41abd1320497fb92fd31fc73af708708af664ac3b56", size = 132432, upload-time = "2025-07-25T14:32:40.619Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/4d/3fc3e5d7115f4f7d01b481e29e5a79bcbcc45711a2723242787455424f40/orjson-3.11.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5adaf01b92e0402a9ac5c3ebe04effe2bbb115f0914a0a53d34ea239a746289", size = 135069, upload-time = "2025-07-25T14:32:41.84Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c6/7585aa8522af896060dc0cd7c336ba6c574ae854416811ee6642c505cc95/orjson-3.11.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6162a1a757a1f1f4a94bc6ffac834a3602e04ad5db022dd8395a54ed9dd51c81", size = 131045, upload-time = "2025-07-25T14:32:43.085Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/4e/b8a0a943793d2708ebc39e743c943251e08ee0f3279c880aefd8e9cb0c70/orjson-3.11.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:78404206977c9f946613d3f916727c189d43193e708d760ea5d4b2087d6b0968", size = 130597, upload-time = "2025-07-25T14:32:44.336Z" },
-    { url = "https://files.pythonhosted.org/packages/72/2b/7d30e2aed2f585d5d385fb45c71d9b16ba09be58c04e8767ae6edc6c9282/orjson-3.11.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:db48f8e81072e26df6cdb0e9fff808c28597c6ac20a13d595756cf9ba1fed48a", size = 404207, upload-time = "2025-07-25T14:32:45.612Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/7e/772369ec66fcbce79477f0891918309594cd00e39b67a68d4c445d2ab754/orjson-3.11.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0c1e394e67ced6bb16fea7054d99fbdd99a539cf4d446d40378d4c06e0a8548d", size = 146628, upload-time = "2025-07-25T14:32:46.981Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/c8/62bdb59229d7e393ae309cef41e32cc1f0b567b21dfd0742da70efb8b40c/orjson-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e7a840752c93d4eecd1378e9bb465c3703e127b58f675cd5c620f361b6cf57a4", size = 135449, upload-time = "2025-07-25T14:32:48.727Z" },
-    { url = "https://files.pythonhosted.org/packages/02/47/1c99aa60e19f781424eabeaacd9e999eafe5b59c81ead4273b773f0f3af1/orjson-3.11.1-cp312-cp312-win32.whl", hash = "sha256:4537b0e09f45d2b74cb69c7f39ca1e62c24c0488d6bf01cd24673c74cd9596bf", size = 136653, upload-time = "2025-07-25T14:32:50.622Z" },
-    { url = "https://files.pythonhosted.org/packages/31/9a/132999929a2892ab07e916669accecc83e5bff17e11a1186b4c6f23231f0/orjson-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:dbee6b050062540ae404530cacec1bf25e56e8d87d8d9b610b935afeb6725cae", size = 131426, upload-time = "2025-07-25T14:32:51.883Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/77/d984ee5a1ca341090902e080b187721ba5d1573a8d9759e0c540975acfb2/orjson-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:f55e557d4248322d87c4673e085c7634039ff04b47bfc823b87149ae12bef60d", size = 126635, upload-time = "2025-07-25T14:32:53.2Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/e9/880ef869e6f66279ce3a381a32afa0f34e29a94250146911eee029e56efc/orjson-3.11.1-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:53cfefe4af059e65aabe9683f76b9c88bf34b4341a77d329227c2424e0e59b0e", size = 240835, upload-time = "2025-07-25T14:32:54.507Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/1f/52039ef3d03eeea21763b46bc99ebe11d9de8510c72b7b5569433084a17e/orjson-3.11.1-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:93d5abed5a6f9e1b6f9b5bf6ed4423c11932b5447c2f7281d3b64e0f26c6d064", size = 129226, upload-time = "2025-07-25T14:32:55.908Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/da/59fdffc9465a760be2cd3764ef9cd5535eec8f095419f972fddb123b6d0e/orjson-3.11.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbf06642f3db2966df504944cdd0eb68ca2717f0353bb20b20acd78109374a6", size = 132261, upload-time = "2025-07-25T14:32:57.538Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/5c/8610911c7e969db7cf928c8baac4b2f1e68d314bc3057acf5ca64f758435/orjson-3.11.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dddf4e78747fa7f2188273f84562017a3c4f0824485b78372513c1681ea7a894", size = 128614, upload-time = "2025-07-25T14:32:58.808Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/a1/a1db9d4310d014c90f3b7e9b72c6fb162cba82c5f46d0b345669eaebdd3a/orjson-3.11.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa3fe8653c9f57f0e16f008e43626485b6723b84b2f741f54d1258095b655912", size = 130968, upload-time = "2025-07-25T14:33:00.038Z" },
-    { url = "https://files.pythonhosted.org/packages/56/ff/11acd1fd7c38ea7a1b5d6bf582ae3da05931bee64620995eb08fd63c77fe/orjson-3.11.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6334d2382aff975a61f6f4d1c3daf39368b887c7de08f7c16c58f485dcf7adb2", size = 132439, upload-time = "2025-07-25T14:33:01.354Z" },
-    { url = "https://files.pythonhosted.org/packages/70/f9/bb564dd9450bf8725e034a8ad7f4ae9d4710a34caf63b85ce1c0c6d40af0/orjson-3.11.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3d0855b643f259ee0cb76fe3df4c04483354409a520a902b067c674842eb6b8", size = 135299, upload-time = "2025-07-25T14:33:03.079Z" },
-    { url = "https://files.pythonhosted.org/packages/94/bb/c8eafe6051405e241dda3691db4d9132d3c3462d1d10a17f50837dd130b4/orjson-3.11.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0eacdfeefd0a79987926476eb16e0245546bedeb8febbbbcf4b653e79257a8e4", size = 131004, upload-time = "2025-07-25T14:33:04.416Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/40/bed8d7dcf1bd2df8813bf010a25f645863a2f75e8e0ebdb2b55784cf1a62/orjson-3.11.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0ed07faf9e4873518c60480325dcbc16d17c59a165532cccfb409b4cdbaeff24", size = 130583, upload-time = "2025-07-25T14:33:05.768Z" },
-    { url = "https://files.pythonhosted.org/packages/57/e7/cfa2eb803ad52d74fbb5424a429b5be164e51d23f1d853e5e037173a5c48/orjson-3.11.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d6d308dd578ae3658f62bb9eba54801533225823cd3248c902be1ebc79b5e014", size = 404218, upload-time = "2025-07-25T14:33:07.117Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/21/bc703af5bc6e9c7e18dcf4404dcc4ec305ab9bb6c82d3aee5952c0c56abf/orjson-3.11.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c4aa13ca959ba6b15c0a98d3d204b850f9dc36c08c9ce422ffb024eb30d6e058", size = 146605, upload-time = "2025-07-25T14:33:08.55Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/fe/d26a0150534c4965a06f556aa68bf3c3b82999d5d7b0facd3af7b390c4af/orjson-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:be3d0653322abc9b68e5bcdaee6cfd58fcbe9973740ab222b87f4d687232ab1f", size = 135434, upload-time = "2025-07-25T14:33:09.967Z" },
-    { url = "https://files.pythonhosted.org/packages/89/b6/1cb28365f08cbcffc464f8512320c6eb6db6a653f03d66de47ea3c19385f/orjson-3.11.1-cp313-cp313-win32.whl", hash = "sha256:4dd34e7e2518de8d7834268846f8cab7204364f427c56fb2251e098da86f5092", size = 136596, upload-time = "2025-07-25T14:33:11.333Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/35/7870d0d3ed843652676d84d8a6038791113eacc85237b673b925802826b8/orjson-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:d6895d32032b6362540e6d0694b19130bb4f2ad04694002dce7d8af588ca5f77", size = 131319, upload-time = "2025-07-25T14:33:12.614Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/3e/5bcd50fd865eb664d4edfdaaaff51e333593ceb5695a22c0d0a0d2b187ba/orjson-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:bb7c36d5d3570fcbb01d24fa447a21a7fe5a41141fd88e78f7994053cc4e28f4", size = 126613, upload-time = "2025-07-25T14:33:13.927Z" },
-    { url = "https://files.pythonhosted.org/packages/61/d8/0a5cd31ed100b4e569e143cb0cddefc21f0bcb8ce284f44bca0bb0e10f3d/orjson-3.11.1-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:7b71ef394327b3d0b39f6ea7ade2ecda2731a56c6a7cbf0d6a7301203b92a89b", size = 240819, upload-time = "2025-07-25T14:33:15.223Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/95/7eb2c76c92192ceca16bc81845ff100bbb93f568b4b94d914b6a4da47d61/orjson-3.11.1-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:77c0fe28ed659b62273995244ae2aa430e432c71f86e4573ab16caa2f2e3ca5e", size = 129218, upload-time = "2025-07-25T14:33:16.637Z" },
-    { url = "https://files.pythonhosted.org/packages/da/84/e6b67f301b18adbbc346882f456bea44daebbd032ba725dbd7b741e3a7f1/orjson-3.11.1-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:1495692f1f1ba2467df429343388a0ed259382835922e124c0cfdd56b3d1f727", size = 132238, upload-time = "2025-07-25T14:33:17.934Z" },
-    { url = "https://files.pythonhosted.org/packages/84/78/a45a86e29d9b2f391f9d00b22da51bc4b46b86b788fd42df2c5fcf3e8005/orjson-3.11.1-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:08c6a762fca63ca4dc04f66c48ea5d2428db55839fec996890e1bfaf057b658c", size = 130998, upload-time = "2025-07-25T14:33:19.282Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/8f/6eb3ee6760d93b2ce996a8529164ee1f5bafbdf64b74c7314b68db622b32/orjson-3.11.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9e26794fe3976810b2c01fda29bd9ac7c91a3c1284b29cc9a383989f7b614037", size = 130559, upload-time = "2025-07-25T14:33:20.589Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/78/9572ae94bdba6813917c9387e7834224c011ea6b4530ade07d718fd31598/orjson-3.11.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4b4b4f8f0b1d3ef8dc73e55363a0ffe012a42f4e2f1a140bf559698dca39b3fa", size = 404231, upload-time = "2025-07-25T14:33:22.019Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/a3/68381ad0757e084927c5ee6cfdeab1c6c89405949ee493db557e60871c4c/orjson-3.11.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:848be553ea35aa89bfefbed2e27c8a41244c862956ab8ba00dc0b27e84fd58de", size = 146658, upload-time = "2025-07-25T14:33:23.675Z" },
-    { url = "https://files.pythonhosted.org/packages/00/db/fac56acf77aab778296c3f541a3eec643266f28ecd71d6c0cba251e47655/orjson-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c964c29711a4b1df52f8d9966f015402a6cf87753a406c1c4405c407dd66fd45", size = 135443, upload-time = "2025-07-25T14:33:25.04Z" },
-    { url = "https://files.pythonhosted.org/packages/76/b1/326fa4b87426197ead61c1eec2eeb3babc9eb33b480ac1f93894e40c8c08/orjson-3.11.1-cp314-cp314-win32.whl", hash = "sha256:33aada2e6b6bc9c540d396528b91e666cedb383740fee6e6a917f561b390ecb1", size = 136643, upload-time = "2025-07-25T14:33:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/8e/2987ae2109f3bfd39680f8a187d1bc09ad7f8fb019dcdc719b08c7242ade/orjson-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:68e10fd804e44e36188b9952543e3fa22f5aa8394da1b5283ca2b423735c06e8", size = 131324, upload-time = "2025-07-25T14:33:27.896Z" },
-    { url = "https://files.pythonhosted.org/packages/21/5f/253e08e6974752b124fbf3a4de3ad53baa766b0cb4a333d47706d307e396/orjson-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:f3cf6c07f8b32127d836be8e1c55d4f34843f7df346536da768e9f73f22078a1", size = 126605, upload-time = "2025-07-25T14:33:29.244Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/64/ce5c07420fe7367bd3da769161f07ae54b35c552468c6eb7947c023a25c6/orjson-3.11.1-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3d593a9e0bccf2c7401ae53625b519a7ad7aa555b1c82c0042b322762dc8af4e", size = 241861, upload-time = "2025-07-25T14:33:30.585Z" },
-    { url = "https://files.pythonhosted.org/packages/94/17/7894ff2867e83d0d5cdda6e41210963a88764b292ec7a91fa93bcb5afd9e/orjson-3.11.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0baad413c498fc1eef568504f11ea46bc71f94b845c075e437da1e2b85b4fb86", size = 132485, upload-time = "2025-07-25T14:33:32.123Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/38/e8f907733e281e65ba912be552fe5ad5b53f0fdddaa0b43c3a9bc0bce5df/orjson-3.11.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:22cf17ae1dae3f9b5f37bfcdba002ed22c98bbdb70306e42dc18d8cc9b50399a", size = 128513, upload-time = "2025-07-25T14:33:33.571Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/49/d6d0f23036a16c9909ca4cb09d53b2bf9341e7b1ae7d03ded302a3673448/orjson-3.11.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e855c1e97208133ce88b3ef6663c9a82ddf1d09390cd0856a1638deee0390c3c", size = 130462, upload-time = "2025-07-25T14:33:35.061Z" },
-    { url = "https://files.pythonhosted.org/packages/04/70/df75afdfe6d3c027c03d656f0a5074159ace27a24dbf22d4af7fabf811df/orjson-3.11.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b5861c5f7acff10599132854c70ab10abf72aebf7c627ae13575e5f20b1ab8fe", size = 132438, upload-time = "2025-07-25T14:33:36.893Z" },
-    { url = "https://files.pythonhosted.org/packages/56/ef/938ae6995965cc7884d8460177bed20248769d1edf99d1904dfd46eebd7d/orjson-3.11.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1e6415c5b5ff3a616a6dafad7b6ec303a9fc625e9313c8e1268fb1370a63dcb", size = 134928, upload-time = "2025-07-25T14:33:38.755Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/2c/97be96e9ed22123724611c8511f306a69e6cd0273d4c6424edda5716d108/orjson-3.11.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:912579642f5d7a4a84d93c5eed8daf0aa34e1f2d3f4dc6571a8e418703f5701e", size = 130903, upload-time = "2025-07-25T14:33:40.585Z" },
-    { url = "https://files.pythonhosted.org/packages/86/ed/7cf17c1621a5a4c6716dfa8099dc9a4153cc8bd402195ae9028d7e5286e3/orjson-3.11.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2092e1d3b33f64e129ff8271642afddc43763c81f2c30823b4a4a4a5f2ea5b55", size = 130793, upload-time = "2025-07-25T14:33:42.397Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/72/add1805918b6af187c193895d38bddc7717eea30d1ea8b25833a9668b469/orjson-3.11.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:b8ac64caba1add2c04e9cd4782d4d0c4d6c554b7a3369bdec1eed7854c98db7b", size = 404283, upload-time = "2025-07-25T14:33:44.035Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/f1/b27c05bab8b49ff2fb30e6c42e8602ae51d6c9dd19564031da37f7ea61ba/orjson-3.11.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:23196b826ebc85c43f8e27bee0ab33c5fb13a29ea47fb4fcd6ebb1e660eb0252", size = 146169, upload-time = "2025-07-25T14:33:46.036Z" },
-    { url = "https://files.pythonhosted.org/packages/91/5b/5a2cdc081bc2093708726887980d8f0c7c0edc31ab0d3c5ccc1db70ede0e/orjson-3.11.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f2d3364cfad43003f1e3d564a069c8866237cca30f9c914b26ed2740b596ed00", size = 135304, upload-time = "2025-07-25T14:33:47.519Z" },
-    { url = "https://files.pythonhosted.org/packages/01/7f/fe09ebaecbaec6a741b29f79ccbbe38736dff51e8413f334067ad914df26/orjson-3.11.1-cp39-cp39-win32.whl", hash = "sha256:20b0dca94ea4ebe4628330de50975b35817a3f52954c1efb6d5d0498a3bbe581", size = 136652, upload-time = "2025-07-25T14:33:49.38Z" },
-    { url = "https://files.pythonhosted.org/packages/97/2f/71fe70d7d06087d8abef423843d880e3d4cf21cfc38c299feebb0a98f7c1/orjson-3.11.1-cp39-cp39-win_amd64.whl", hash = "sha256:200c3ad7ed8b5d31d49143265dfebd33420c4b61934ead16833b5cd2c3d241be", size = 131373, upload-time = "2025-07-25T14:33:51.359Z" },
+version = "3.11.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/1d/5e0ae38788bdf0721326695e65fdf41405ed535f633eb0df0f06f57552fa/orjson-3.11.2.tar.gz", hash = "sha256:91bdcf5e69a8fd8e8bdb3de32b31ff01d2bd60c1e8d5fe7d5afabdcf19920309", size = 5470739, upload-time = "2025-08-12T15:12:28.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/7b/7aebe925c6b1c46c8606a960fe1d6b681fccd4aaf3f37cd647c3309d6582/orjson-3.11.2-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:d6b8a78c33496230a60dc9487118c284c15ebdf6724386057239641e1eb69761", size = 226896, upload-time = "2025-08-12T15:10:22.02Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/39/c952c9b0d51063e808117dd1e53668a2e4325cc63cfe7df453d853ee8680/orjson-3.11.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc04036eeae11ad4180d1f7b5faddb5dab1dee49ecd147cd431523869514873b", size = 111845, upload-time = "2025-08-12T15:10:24.963Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/dc/90b7f29be38745eeacc30903b693f29fcc1097db0c2a19a71ffb3e9f2a5f/orjson-3.11.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9c04325839c5754c253ff301cee8aaed7442d974860a44447bb3be785c411c27", size = 116395, upload-time = "2025-08-12T15:10:26.314Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c2/fe84ba63164c22932b8d59b8810e2e58590105293a259e6dd1bfaf3422c9/orjson-3.11.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32769e04cd7fdc4a59854376211145a1bbbc0aea5e9d6c9755d3d3c301d7c0df", size = 118768, upload-time = "2025-08-12T15:10:27.605Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ce/d9748ec69b1a4c29b8e2bab8233e8c41c583c69f515b373f1fb00247d8c9/orjson-3.11.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0ff285d14917ea1408a821786e3677c5261fa6095277410409c694b8e7720ae0", size = 120887, upload-time = "2025-08-12T15:10:29.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/66/b90fac8e4a76e83f981912d7f9524d402b31f6c1b8bff3e498aa321c326c/orjson-3.11.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2662f908114864b63ff75ffe6ffacf996418dd6cc25e02a72ad4bda81b1ec45a", size = 123650, upload-time = "2025-08-12T15:10:30.602Z" },
+    { url = "https://files.pythonhosted.org/packages/33/81/56143898d1689c7f915ac67703efb97e8f2f8d5805ce8c2c3fd0f2bb6e3d/orjson-3.11.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab463cf5d08ad6623a4dac1badd20e88a5eb4b840050c4812c782e3149fe2334", size = 121287, upload-time = "2025-08-12T15:10:31.868Z" },
+    { url = "https://files.pythonhosted.org/packages/80/de/f9c6d00c127be766a3739d0d85b52a7c941e437d8dd4d573e03e98d0f89c/orjson-3.11.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:64414241bde943cbf3c00d45fcb5223dca6d9210148ba984aae6b5d63294502b", size = 119637, upload-time = "2025-08-12T15:10:33.078Z" },
+    { url = "https://files.pythonhosted.org/packages/67/4c/ab70c7627022d395c1b4eb5badf6196b7144e82b46a3a17ed2354f9e592d/orjson-3.11.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:7773e71c0ae8c9660192ff144a3d69df89725325e3d0b6a6bb2c50e5ebaf9b84", size = 392478, upload-time = "2025-08-12T15:10:34.669Z" },
+    { url = "https://files.pythonhosted.org/packages/77/91/d890b873b69311db4fae2624c5603c437df9c857fb061e97706dac550a77/orjson-3.11.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:652ca14e283b13ece35bf3a86503c25592f294dbcfc5bb91b20a9c9a62a3d4be", size = 134343, upload-time = "2025-08-12T15:10:35.978Z" },
+    { url = "https://files.pythonhosted.org/packages/47/16/1aa248541b4830274a079c4aeb2aa5d1ff17c3f013b1d0d8d16d0848f3de/orjson-3.11.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:26e99e98df8990ecfe3772bbdd7361f602149715c2cbc82e61af89bfad9528a4", size = 123887, upload-time = "2025-08-12T15:10:37.601Z" },
+    { url = "https://files.pythonhosted.org/packages/95/e4/7419833c55ac8b5f385d00c02685a260da1f391e900fc5c3e0b797e0d506/orjson-3.11.2-cp310-cp310-win32.whl", hash = "sha256:5814313b3e75a2be7fe6c7958201c16c4560e21a813dbad25920752cecd6ad66", size = 124560, upload-time = "2025-08-12T15:10:38.966Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f8/27ca7ef3e194c462af32ce1883187f5ec483650c559166f0de59c4c2c5f0/orjson-3.11.2-cp310-cp310-win_amd64.whl", hash = "sha256:dc471ce2225ab4c42ca672f70600d46a8b8e28e8d4e536088c1ccdb1d22b35ce", size = 119700, upload-time = "2025-08-12T15:10:40.911Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7d/e295df1ac9920cbb19fb4c1afa800e86f175cb657143aa422337270a4782/orjson-3.11.2-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:888b64ef7eaeeff63f773881929434a5834a6a140a63ad45183d59287f07fc6a", size = 226502, upload-time = "2025-08-12T15:10:42.284Z" },
+    { url = "https://files.pythonhosted.org/packages/65/21/ffb0f10ea04caf418fb4e7ad1fda4b9ab3179df9d7a33b69420f191aadd5/orjson-3.11.2-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:83387cc8b26c9fa0ae34d1ea8861a7ae6cff8fb3e346ab53e987d085315a728e", size = 115999, upload-time = "2025-08-12T15:10:43.738Z" },
+    { url = "https://files.pythonhosted.org/packages/90/d5/8da1e252ac3353d92e6f754ee0c85027c8a2cda90b6899da2be0df3ef83d/orjson-3.11.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7e35f003692c216d7ee901b6b916b5734d6fc4180fcaa44c52081f974c08e17", size = 111563, upload-time = "2025-08-12T15:10:45.301Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/81/baabc32e52c570b0e4e1044b1bd2ccbec965e0de3ba2c13082255efa2006/orjson-3.11.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4a0a4c29ae90b11d0c00bcc31533854d89f77bde2649ec602f512a7e16e00640", size = 116222, upload-time = "2025-08-12T15:10:46.92Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/da2ad55ad80b49b560dce894c961477d0e76811ee6e614b301de9f2f8728/orjson-3.11.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:585d712b1880f68370108bc5534a257b561672d1592fae54938738fe7f6f1e33", size = 118594, upload-time = "2025-08-12T15:10:48.488Z" },
+    { url = "https://files.pythonhosted.org/packages/61/be/014f7eab51449f3c894aa9bbda2707b5340c85650cb7d0db4ec9ae280501/orjson-3.11.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d08e342a7143f8a7c11f1c4033efe81acbd3c98c68ba1b26b96080396019701f", size = 120700, upload-time = "2025-08-12T15:10:49.811Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/ae/c217903a30c51341868e2d8c318c59a8413baa35af54d7845071c8ccd6fe/orjson-3.11.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29c0f84fc50398773a702732c87cd622737bf11c0721e6db3041ac7802a686fb", size = 123433, upload-time = "2025-08-12T15:10:51.06Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c2/b3c346f78b1ff2da310dd300cb0f5d32167f872b4d3bb1ad122c889d97b0/orjson-3.11.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:140f84e3c8d4c142575898c91e3981000afebf0333df753a90b3435d349a5fe5", size = 121061, upload-time = "2025-08-12T15:10:52.381Z" },
+    { url = "https://files.pythonhosted.org/packages/00/c8/c97798f6010327ffc75ad21dd6bca11ea2067d1910777e798c2849f1c68f/orjson-3.11.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96304a2b7235e0f3f2d9363ddccdbfb027d27338722fe469fe656832a017602e", size = 119410, upload-time = "2025-08-12T15:10:53.692Z" },
+    { url = "https://files.pythonhosted.org/packages/37/fd/df720f7c0e35694617b7f95598b11a2cb0374661d8389703bea17217da53/orjson-3.11.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3d7612bb227d5d9582f1f50a60bd55c64618fc22c4a32825d233a4f2771a428a", size = 392294, upload-time = "2025-08-12T15:10:55.079Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/52/0120d18f60ab0fe47531d520372b528a45c9a25dcab500f450374421881c/orjson-3.11.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a134587d18fe493befc2defffef2a8d27cfcada5696cb7234de54a21903ae89a", size = 134134, upload-time = "2025-08-12T15:10:56.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/10/1f967671966598366de42f07e92b0fc694ffc66eafa4b74131aeca84915f/orjson-3.11.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0b84455e60c4bc12c1e4cbaa5cfc1acdc7775a9da9cec040e17232f4b05458bd", size = 123745, upload-time = "2025-08-12T15:10:57.907Z" },
+    { url = "https://files.pythonhosted.org/packages/43/eb/76081238671461cfd0f47e0c24f408ffa66184237d56ef18c33e86abb612/orjson-3.11.2-cp311-cp311-win32.whl", hash = "sha256:f0660efeac223f0731a70884e6914a5f04d613b5ae500744c43f7bf7b78f00f9", size = 124393, upload-time = "2025-08-12T15:10:59.267Z" },
+    { url = "https://files.pythonhosted.org/packages/26/76/cc598c1811ba9ba935171267b02e377fc9177489efce525d478a2999d9cc/orjson-3.11.2-cp311-cp311-win_amd64.whl", hash = "sha256:955811c8405251d9e09cbe8606ad8fdef49a451bcf5520095a5ed38c669223d8", size = 119561, upload-time = "2025-08-12T15:11:00.559Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/17/c48011750f0489006f7617b0a3cebc8230f36d11a34e7e9aca2085f07792/orjson-3.11.2-cp311-cp311-win_arm64.whl", hash = "sha256:2e4d423a6f838552e3a6d9ec734b729f61f88b1124fd697eab82805ea1a2a97d", size = 114186, upload-time = "2025-08-12T15:11:01.931Z" },
+    { url = "https://files.pythonhosted.org/packages/40/02/46054ebe7996a8adee9640dcad7d39d76c2000dc0377efa38e55dc5cbf78/orjson-3.11.2-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:901d80d349d8452162b3aa1afb82cec5bee79a10550660bc21311cc61a4c5486", size = 226528, upload-time = "2025-08-12T15:11:03.317Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/6b6f0b4d8aea1137436546b990f71be2cd8bd870aa2f5aa14dba0fcc95dc/orjson-3.11.2-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:cf3bd3967a360e87ee14ed82cb258b7f18c710dacf3822fb0042a14313a673a1", size = 115931, upload-time = "2025-08-12T15:11:04.759Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/05/4205cc97c30e82a293dd0d149b1a89b138ebe76afeca66fc129fa2aa4e6a/orjson-3.11.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26693dde66910078229a943e80eeb99fdce6cd2c26277dc80ead9f3ab97d2131", size = 111382, upload-time = "2025-08-12T15:11:06.468Z" },
+    { url = "https://files.pythonhosted.org/packages/50/c7/b8a951a93caa821f9272a7c917115d825ae2e4e8768f5ddf37968ec9de01/orjson-3.11.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4ad4c8acb50a28211c33fc7ef85ddf5cb18d4636a5205fd3fa2dce0411a0e30c", size = 116271, upload-time = "2025-08-12T15:11:07.845Z" },
+    { url = "https://files.pythonhosted.org/packages/17/03/1006c7f8782d5327439e26d9b0ec66500ea7b679d4bbb6b891d2834ab3ee/orjson-3.11.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:994181e7f1725bb5f2d481d7d228738e0743b16bf319ca85c29369c65913df14", size = 119086, upload-time = "2025-08-12T15:11:09.329Z" },
+    { url = "https://files.pythonhosted.org/packages/44/61/57d22bc31f36a93878a6f772aea76b2184102c6993dea897656a66d18c74/orjson-3.11.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dbb79a0476393c07656b69c8e763c3cc925fa8e1d9e9b7d1f626901bb5025448", size = 120724, upload-time = "2025-08-12T15:11:10.674Z" },
+    { url = "https://files.pythonhosted.org/packages/78/a9/4550e96b4c490c83aea697d5347b8f7eb188152cd7b5a38001055ca5b379/orjson-3.11.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:191ed27a1dddb305083d8716af413d7219f40ec1d4c9b0e977453b4db0d6fb6c", size = 123577, upload-time = "2025-08-12T15:11:12.015Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/86/09b8cb3ebd513d708ef0c92d36ac3eebda814c65c72137b0a82d6d688fc4/orjson-3.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0afb89f16f07220183fd00f5f297328ed0a68d8722ad1b0c8dcd95b12bc82804", size = 121195, upload-time = "2025-08-12T15:11:13.399Z" },
+    { url = "https://files.pythonhosted.org/packages/37/68/7b40b39ac2c1c644d4644e706d0de6c9999764341cd85f2a9393cb387661/orjson-3.11.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ab6e6b4e93b1573a026b6ec16fca9541354dd58e514b62c558b58554ae04307", size = 119234, upload-time = "2025-08-12T15:11:15.134Z" },
+    { url = "https://files.pythonhosted.org/packages/40/7c/bb6e7267cd80c19023d44d8cbc4ea4ed5429fcd4a7eb9950f50305697a28/orjson-3.11.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:9cb23527efb61fb75527df55d20ee47989c4ee34e01a9c98ee9ede232abf6219", size = 392250, upload-time = "2025-08-12T15:11:16.604Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6730ace05583dbca7c1b406d59f4266e48cd0d360566e71482420fb849fc/orjson-3.11.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a4dd1268e4035af21b8a09e4adf2e61f87ee7bf63b86d7bb0a237ac03fad5b45", size = 134572, upload-time = "2025-08-12T15:11:18.205Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0f/7d3e03a30d5aac0432882b539a65b8c02cb6dd4221ddb893babf09c424cc/orjson-3.11.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff8b155b145eaf5a9d94d2c476fbe18d6021de93cf36c2ae2c8c5b775763f14e", size = 123869, upload-time = "2025-08-12T15:11:19.554Z" },
+    { url = "https://files.pythonhosted.org/packages/45/80/1513265eba6d4a960f078f4b1d2bff94a571ab2d28c6f9835e03dfc65cc6/orjson-3.11.2-cp312-cp312-win32.whl", hash = "sha256:ae3bb10279d57872f9aba68c9931aa71ed3b295fa880f25e68da79e79453f46e", size = 124430, upload-time = "2025-08-12T15:11:20.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/61/eadf057b68a332351eeb3d89a4cc538d14f31cd8b5ec1b31a280426ccca2/orjson-3.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:d026e1967239ec11a2559b4146a61d13914504b396f74510a1c4d6b19dfd8732", size = 119598, upload-time = "2025-08-12T15:11:22.372Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/3f/7f4b783402143d965ab7e9a2fc116fdb887fe53bdce7d3523271cd106098/orjson-3.11.2-cp312-cp312-win_arm64.whl", hash = "sha256:59f8d5ad08602711af9589375be98477d70e1d102645430b5a7985fdbf613b36", size = 114052, upload-time = "2025-08-12T15:11:23.762Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/0dd6b4750eb556ae4e2c6a9cb3e219ec642e9c6d95f8ebe5dc9020c67204/orjson-3.11.2-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a079fdba7062ab396380eeedb589afb81dc6683f07f528a03b6f7aae420a0219", size = 226419, upload-time = "2025-08-12T15:11:25.517Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d5/e67f36277f78f2af8a4690e0c54da6b34169812f807fd1b4bfc4dbcf9558/orjson-3.11.2-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:6a5f62ebbc530bb8bb4b1ead103647b395ba523559149b91a6c545f7cd4110ad", size = 115803, upload-time = "2025-08-12T15:11:27.357Z" },
+    { url = "https://files.pythonhosted.org/packages/24/37/ff8bc86e0dacc48f07c2b6e20852f230bf4435611bab65e3feae2b61f0ae/orjson-3.11.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7df6c7b8b0931feb3420b72838c3e2ba98c228f7aa60d461bc050cf4ca5f7b2", size = 111337, upload-time = "2025-08-12T15:11:28.805Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/25/37d4d3e8079ea9784ea1625029988e7f4594ce50d4738b0c1e2bf4a9e201/orjson-3.11.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6f59dfea7da1fced6e782bb3699718088b1036cb361f36c6e4dd843c5111aefe", size = 116222, upload-time = "2025-08-12T15:11:30.18Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/32/a63fd9c07fce3b4193dcc1afced5dd4b0f3a24e27556604e9482b32189c9/orjson-3.11.2-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edf49146520fef308c31aa4c45b9925fd9c7584645caca7c0c4217d7900214ae", size = 119020, upload-time = "2025-08-12T15:11:31.59Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/b6/400792b8adc3079a6b5d649264a3224d6342436d9fac9a0ed4abc9dc4596/orjson-3.11.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50995bbeb5d41a32ad15e023305807f561ac5dcd9bd41a12c8d8d1d2c83e44e6", size = 120721, upload-time = "2025-08-12T15:11:33.035Z" },
+    { url = "https://files.pythonhosted.org/packages/40/f3/31ab8f8c699eb9e65af8907889a0b7fef74c1d2b23832719a35da7bb0c58/orjson-3.11.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2cc42960515076eb639b705f105712b658c525863d89a1704d984b929b0577d1", size = 123574, upload-time = "2025-08-12T15:11:34.433Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a6/ce4287c412dff81878f38d06d2c80845709c60012ca8daf861cb064b4574/orjson-3.11.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c56777cab2a7b2a8ea687fedafb84b3d7fdafae382165c31a2adf88634c432fa", size = 121225, upload-time = "2025-08-12T15:11:36.133Z" },
+    { url = "https://files.pythonhosted.org/packages/69/b0/7a881b2aef4fed0287d2a4fbb029d01ed84fa52b4a68da82bdee5e50598e/orjson-3.11.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:07349e88025b9b5c783077bf7a9f401ffbfb07fd20e86ec6fc5b7432c28c2c5e", size = 119201, upload-time = "2025-08-12T15:11:37.642Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/98/a325726b37f7512ed6338e5e65035c3c6505f4e628b09a5daf0419f054ea/orjson-3.11.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:45841fbb79c96441a8c58aa29ffef570c5df9af91f0f7a9572e5505e12412f15", size = 392193, upload-time = "2025-08-12T15:11:39.153Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/4f/a7194f98b0ce1d28190e0c4caa6d091a3fc8d0107ad2209f75c8ba398984/orjson-3.11.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:13d8d8db6cd8d89d4d4e0f4161acbbb373a4d2a4929e862d1d2119de4aa324ac", size = 134548, upload-time = "2025-08-12T15:11:40.768Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5e/b84caa2986c3f472dc56343ddb0167797a708a8d5c3be043e1e2677b55df/orjson-3.11.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51da1ee2178ed09c00d09c1b953e45846bbc16b6420965eb7a913ba209f606d8", size = 123798, upload-time = "2025-08-12T15:11:42.164Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/5b/e398449080ce6b4c8fcadad57e51fa16f65768e1b142ba90b23ac5d10801/orjson-3.11.2-cp313-cp313-win32.whl", hash = "sha256:51dc033df2e4a4c91c0ba4f43247de99b3cbf42ee7a42ee2b2b2f76c8b2f2cb5", size = 124402, upload-time = "2025-08-12T15:11:44.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/429e4608e124debfc4790bfc37131f6958e59510ba3b542d5fc163be8e5f/orjson-3.11.2-cp313-cp313-win_amd64.whl", hash = "sha256:29d91d74942b7436f29b5d1ed9bcfc3f6ef2d4f7c4997616509004679936650d", size = 119498, upload-time = "2025-08-12T15:11:45.864Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/04/f8b5f317cce7ad3580a9ad12d7e2df0714dfa8a83328ecddd367af802f5b/orjson-3.11.2-cp313-cp313-win_arm64.whl", hash = "sha256:4ca4fb5ac21cd1e48028d4f708b1bb13e39c42d45614befd2ead004a8bba8535", size = 114051, upload-time = "2025-08-12T15:11:47.555Z" },
+    { url = "https://files.pythonhosted.org/packages/74/83/2c363022b26c3c25b3708051a19d12f3374739bb81323f05b284392080c0/orjson-3.11.2-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3dcba7101ea6a8d4ef060746c0f2e7aa8e2453a1012083e1ecce9726d7554cb7", size = 226406, upload-time = "2025-08-12T15:11:49.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/a7/aa3c973de0b33fc93b4bd71691665ffdfeae589ea9d0625584ab10a7d0f5/orjson-3.11.2-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:15d17bdb76a142e1f55d91913e012e6e6769659daa6bfef3ef93f11083137e81", size = 115788, upload-time = "2025-08-12T15:11:50.992Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/f2/e45f233dfd09fdbb052ec46352363dca3906618e1a2b264959c18f809d0b/orjson-3.11.2-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:53c9e81768c69d4b66b8876ec3c8e431c6e13477186d0db1089d82622bccd19f", size = 111318, upload-time = "2025-08-12T15:11:52.495Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/23/cf5a73c4da6987204cbbf93167f353ff0c5013f7c5e5ef845d4663a366da/orjson-3.11.2-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:d4f13af59a7b84c1ca6b8a7ab70d608f61f7c44f9740cd42409e6ae7b6c8d8b7", size = 121231, upload-time = "2025-08-12T15:11:53.941Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1d/47468a398ae68a60cc21e599144e786e035bb12829cb587299ecebc088f1/orjson-3.11.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bde64aa469b5ee46cc960ed241fae3721d6a8801dacb2ca3466547a2535951e4", size = 119204, upload-time = "2025-08-12T15:11:55.409Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/d9/f99433d89b288b5bc8836bffb32a643f805e673cf840ef8bab6e73ced0d1/orjson-3.11.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:b5ca86300aeb383c8fa759566aca065878d3d98c3389d769b43f0a2e84d52c5f", size = 392237, upload-time = "2025-08-12T15:11:57.18Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/dc/1b9d80d40cebef603325623405136a29fb7d08c877a728c0943dd066c29a/orjson-3.11.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:24e32a558ebed73a6a71c8f1cbc163a7dd5132da5270ff3d8eeb727f4b6d1bc7", size = 134578, upload-time = "2025-08-12T15:11:58.844Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b3/72e7a4c5b6485ef4e83ef6aba7f1dd041002bad3eb5d1d106ca5b0fc02c6/orjson-3.11.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e36319a5d15b97e4344110517450396845cc6789aed712b1fbf83c1bd95792f6", size = 123799, upload-time = "2025-08-12T15:12:00.352Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/3e/a3d76b392e7acf9b34dc277171aad85efd6accc75089bb35b4c614990ea9/orjson-3.11.2-cp314-cp314-win32.whl", hash = "sha256:40193ada63fab25e35703454d65b6afc71dbc65f20041cb46c6d91709141ef7f", size = 124461, upload-time = "2025-08-12T15:12:01.854Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/75c6a596ff8df9e4a5894813ff56695f0a218e6ea99420b4a645c4f7795d/orjson-3.11.2-cp314-cp314-win_amd64.whl", hash = "sha256:7c8ac5f6b682d3494217085cf04dadae66efee45349ad4ee2a1da3c97e2305a8", size = 119494, upload-time = "2025-08-12T15:12:03.337Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3d/9e74742fc261c5ca473c96bb3344d03995869e1dc6402772c60afb97736a/orjson-3.11.2-cp314-cp314-win_arm64.whl", hash = "sha256:21cf261e8e79284242e4cb1e5924df16ae28255184aafeff19be1405f6d33f67", size = 114046, upload-time = "2025-08-12T15:12:04.87Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/08/8ebc6dcac0938376b7e61dff432c33958505ae4c185dda3fa1e6f46ac40b/orjson-3.11.2-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:957f10c7b5bce3d3f2ad577f3b307c784f5dabafcce3b836229c269c11841c86", size = 226498, upload-time = "2025-08-12T15:12:06.51Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/74/a97c8e2bc75a27dfeeb1b289645053f1889125447f3b7484a2e34ac55d2a/orjson-3.11.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a669e31ab8eb466c9142ac7a4be2bb2758ad236a31ef40dcd4cf8774ab40f33", size = 111529, upload-time = "2025-08-12T15:12:08.21Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c3/55121b5722a1a4e4610a411866cfeada5314dc498cd42435b590353009d2/orjson-3.11.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:adedf7d887416c51ad49de3c53b111887e0b63db36c6eb9f846a8430952303d8", size = 116213, upload-time = "2025-08-12T15:12:09.776Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d3/1c810fa36a749157f1ec68f825b09d5b6958ed5eaf66c7b89bc0f1656517/orjson-3.11.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ad8873979659ad98fc56377b9c5b93eb8059bf01e6412f7abf7dbb3d637a991", size = 118594, upload-time = "2025-08-12T15:12:11.363Z" },
+    { url = "https://files.pythonhosted.org/packages/09/9c/052a6619857aba27899246c1ac9e1566fe976dbb48c2d2d177eb269e6d92/orjson-3.11.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9482ef83b2bf796157566dd2d2742a8a1e377045fe6065fa67acb1cb1d21d9a3", size = 120706, upload-time = "2025-08-12T15:12:13.265Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/91/ed0632b8bafa5534d40483ca14f4b7b7e8f27a016f52ff771420b3591574/orjson-3.11.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:73cee7867c1fcbd1cc5b6688b3e13db067f968889242955780123a68b3d03316", size = 123412, upload-time = "2025-08-12T15:12:14.807Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3d/058184ae52a2035098939329f8864c5e28c3bbd660f80d4f687f4fd3e629/orjson-3.11.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:465166773265f3cc25db10199f5d11c81898a309e26a2481acf33ddbec433fda", size = 121011, upload-time = "2025-08-12T15:12:16.352Z" },
+    { url = "https://files.pythonhosted.org/packages/57/ab/70e7a2c26a29878ad81ac551f3d11e184efafeed92c2ea15301ac71e2b44/orjson-3.11.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:bc000190a7b1d2d8e36cba990b3209a1e15c0efb6c7750e87f8bead01afc0d46", size = 119387, upload-time = "2025-08-12T15:12:17.88Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/f1/532be344579590c2faa3d9926ec446e8e030d6d04359a8d6f9b3f4d18283/orjson-3.11.2-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:df3fdd8efa842ccbb81135d6f58a73512f11dba02ed08d9466261c2e9417af4e", size = 392280, upload-time = "2025-08-12T15:12:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/90/dfb90d82ee7447ba0c5315b1012f36336d34a4b468f5896092926eb2921b/orjson-3.11.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3dacfc621be3079ec69e0d4cb32e3764067726e0ef5a5576428f68b6dc85b4f6", size = 134127, upload-time = "2025-08-12T15:12:22.053Z" },
+    { url = "https://files.pythonhosted.org/packages/17/cb/d113d03dfaee4933b0f6e0f3d358886db1468302bb74f1f3c59d9229ce12/orjson-3.11.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9fdff73a029cde5f4a1cf5ec9dbc6acab98c9ddd69f5580c2b3f02ce43ba9f9f", size = 123722, upload-time = "2025-08-12T15:12:23.642Z" },
+    { url = "https://files.pythonhosted.org/packages/55/78/a89748f500d7cf909fe0b30093ab87d256c279106048e985269a5530c0a1/orjson-3.11.2-cp39-cp39-win32.whl", hash = "sha256:b1efbdc479c6451138c3733e415b4d0e16526644e54e2f3689f699c4cda303bf", size = 124391, upload-time = "2025-08-12T15:12:25.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/50/e436f1356650cf96ff62c386dbfeb9ef8dd9cd30c4296103244e7fae2d15/orjson-3.11.2-cp39-cp39-win_amd64.whl", hash = "sha256:c9ec0cc0d4308cad1e38a1ee23b64567e2ff364c2a3fe3d6cbc69cf911c45712", size = 119547, upload-time = "2025-08-12T15:12:26.77Z" },
 ]
 
 [[package]]
@@ -4858,8 +4858,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/86/85/29d216002d4593c2ce1c0ec2cec46dda77bfbcd221e24caa6e85eff53d89/sqlalchemy-2.0.43-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9df7126fd9db49e3a5a3999442cc67e9ee8971f3cb9644250107d7296cb2a164", size = 3219363, upload-time = "2025-08-11T15:56:39.11Z" },
     { url = "https://files.pythonhosted.org/packages/b6/e4/bd78b01919c524f190b4905d47e7630bf4130b9f48fd971ae1c6225b6f6a/sqlalchemy-2.0.43-cp313-cp313-win32.whl", hash = "sha256:7f1ac7828857fcedb0361b48b9ac4821469f7694089d15550bbcf9ab22564a1d", size = 2096718, upload-time = "2025-08-11T15:55:05.349Z" },
     { url = "https://files.pythonhosted.org/packages/ac/a5/ca2f07a2a201f9497de1928f787926613db6307992fe5cda97624eb07c2f/sqlalchemy-2.0.43-cp313-cp313-win_amd64.whl", hash = "sha256:971ba928fcde01869361f504fcff3b7143b47d30de188b11c6357c0505824197", size = 2123200, upload-time = "2025-08-11T15:55:07.932Z" },
+    { url = "https://files.pythonhosted.org/packages/92/95/ddb5acf74a71e0fa4f9410c7d8555f169204ae054a49693b3cd31d0bf504/sqlalchemy-2.0.43-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ceb5c832cc30663aeaf5e39657712f4c4241ad1f638d487ef7216258f6d41fe7", size = 2136445, upload-time = "2025-08-12T17:29:06.145Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d4/7d7ea7dfbc1ddb0aa54dd63a686cd43842192b8e1bfb5315bb052925f704/sqlalchemy-2.0.43-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:11f43c39b4b2ec755573952bbcc58d976779d482f6f832d7f33a8d869ae891bf", size = 2126411, upload-time = "2025-08-12T17:29:08.138Z" },
     { url = "https://files.pythonhosted.org/packages/07/bd/123ba09bec14112de10e49d8835e6561feb24fd34131099d98d28d34f106/sqlalchemy-2.0.43-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:413391b2239db55be14fa4223034d7e13325a1812c8396ecd4f2c08696d5ccad", size = 3221776, upload-time = "2025-08-11T16:00:30.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/35/553e45d5b91b15980c13e1dbcd7591f49047589843fff903c086d7985afb/sqlalchemy-2.0.43-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c379e37b08c6c527181a397212346be39319fb64323741d23e46abd97a400d34", size = 3221665, upload-time = "2025-08-12T17:29:11.307Z" },
     { url = "https://files.pythonhosted.org/packages/07/4d/ff03e516087251da99bd879b5fdb2c697ff20295c836318dda988e12ec19/sqlalchemy-2.0.43-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:03d73ab2a37d9e40dec4984d1813d7878e01dbdc742448d44a7341b7a9f408c7", size = 3160067, upload-time = "2025-08-11T16:00:33.148Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/88/cbc7caa186ecdc5dea013e9ccc00d78b93a6638dc39656a42369a9536458/sqlalchemy-2.0.43-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8cee08f15d9e238ede42e9bbc1d6e7158d0ca4f176e4eab21f88ac819ae3bd7b", size = 3184462, upload-time = "2025-08-12T17:29:14.919Z" },
     { url = "https://files.pythonhosted.org/packages/ab/69/f8bbd43080b6fa75cb44ff3a1cc99aaae538dd0ade1a58206912b2565d72/sqlalchemy-2.0.43-cp39-cp39-win32.whl", hash = "sha256:b3edaec7e8b6dc5cd94523c6df4f294014df67097c8217a89929c99975811414", size = 2104031, upload-time = "2025-08-11T15:48:56.453Z" },
     { url = "https://files.pythonhosted.org/packages/36/39/2ec1b0e7a4f44d833d924e7bfca8054c72e37eb73f4d02795d16d8b0230a/sqlalchemy-2.0.43-cp39-cp39-win_amd64.whl", hash = "sha256:227119ce0a89e762ecd882dc661e0aa677a690c914e358f0dd8932a2e8b2765b", size = 2128007, upload-time = "2025-08-11T15:48:57.872Z" },
     { url = "https://files.pythonhosted.org/packages/b8/d9/13bdde6521f322861fab67473cec4b1cc8999f3871953531cf61945fad92/sqlalchemy-2.0.43-py3-none-any.whl", hash = "sha256:1681c21dd2ccee222c2fe0bef671d1aef7c504087c9c4e800371cfcc8ac966fc", size = 1924759, upload-time = "2025-08-11T15:39:53.024Z" },
@@ -4953,7 +4957,7 @@ wheels = [
 
 [[package]]
 name = "sqlspec"
-version = "0.16.0"
+version = "0.16.1"
 source = { editable = "." }
 dependencies = [
     { name = "eval-type-backport", marker = "python_full_version < '3.10'" },