revert: remove unproven hot-path optimizations

Author: cofin

sqlspec/builder/_explain.py

@@ -4,7 +4,7 @@
 dialect-aware SQL generation.
 """
 
-from typing import TYPE_CHECKING, Any, Final
+from typing import TYPE_CHECKING, Any
 
 from mypy_extensions import trait
 from sqlglot import Dialect
@@ -44,12 +44,6 @@
 ORACLE_DIALECTS = frozenset({"oracle"})
 BIGQUERY_DIALECTS = frozenset({"bigquery"})
 SPANNER_DIALECTS = frozenset({"spanner"})
-_MYSQL_EXPLAIN_FORMAT_MAP: Final[dict[ExplainFormat, str]] = {
-    ExplainFormat.JSON: "JSON",
-    ExplainFormat.TREE: "TREE",
-    ExplainFormat.TRADITIONAL: "TRADITIONAL",
-    ExplainFormat.TEXT: "TRADITIONAL",
-}
 
 
 def normalize_dialect_name(dialect: "DialectType | None") -> str | None:
@@ -131,7 +125,13 @@ def build_mysql_explain(statement_sql: str, options: "ExplainOptions") -> str:
         return f"EXPLAIN ANALYZE {statement_sql}"
 
     if options.format is not None:
-        fmt = _MYSQL_EXPLAIN_FORMAT_MAP.get(options.format, "TRADITIONAL")
+        format_map = {
+            ExplainFormat.JSON: "JSON",
+            ExplainFormat.TREE: "TREE",
+            ExplainFormat.TRADITIONAL: "TRADITIONAL",
+            ExplainFormat.TEXT: "TRADITIONAL",
+        }
+        fmt = format_map.get(options.format, "TRADITIONAL")
         return f"EXPLAIN FORMAT = {fmt} {statement_sql}"
 
     return f"EXPLAIN {statement_sql}"

sqlspec/builder/_factory.py

@@ -5,7 +5,7 @@
 
 import hashlib
 import logging
-from typing import TYPE_CHECKING, Any, Final, TypeVar, Union, cast, final
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast, final
 
 import sqlglot
 from sqlglot import exp
@@ -96,7 +96,6 @@
 
 MIN_SQL_LIKE_STRING_LENGTH = 6
 MIN_DECODE_ARGS = 2
-_MERGE_SUPPORTED_DIALECTS: Final[frozenset[str]] = frozenset({"postgres", "postgresql", "oracle", "bigquery"})
 SQL_STARTERS = {
     "SELECT",
     "INSERT",
@@ -283,7 +282,15 @@ def __call__(self, statement: str, dialect: DialectType = None) -> "Any":
             msg = f"Failed to parse SQL: {e}"
             raise SQLBuilderError(msg) from e
         actual_type = type(parsed_expr).__name__.upper()
-        actual_type_str = actual_type
+        expr_type_map = {
+            "SELECT": "SELECT",
+            "INSERT": "INSERT",
+            "UPDATE": "UPDATE",
+            "DELETE": "DELETE",
+            "MERGE": "MERGE",
+            "WITH": "WITH",
+        }
+        actual_type_str = expr_type_map.get(actual_type, actual_type)
         if actual_type_str == "SELECT" or (
             actual_type_str == "WITH" and parsed_expr.this and isinstance(parsed_expr.this, exp.Select)
         ):
@@ -453,7 +460,9 @@ def upsert(self, table: str, dialect: DialectType = None) -> "Merge | Insert":
         builder_dialect = dialect or self.dialect
         dialect_str = str(builder_dialect).lower() if builder_dialect else None
 
-        if dialect_str in _MERGE_SUPPORTED_DIALECTS:
+        merge_supported = {"postgres", "postgresql", "oracle", "bigquery"}
+
+        if dialect_str in merge_supported:
             return self.merge(table, dialect=builder_dialect)
 
         return self.insert(table, dialect=builder_dialect)

sqlspec/builder/_vector_distance.py

@@ -34,24 +34,6 @@
 _ORACLE_OPERATOR_TRANSFORM: _OperatorTransform | None = None
 _BIGQUERY_OPERATOR_TRANSFORM: _OperatorTransform | None = None
 _DUCKDB_OPERATOR_TRANSFORM: _OperatorTransform | None = None
-_POSTGRES_VECTOR_OPERATOR_MAP: Final[dict[str, str]] = {"euclidean": "<->", "cosine": "<=>", "inner_product": "<#>"}
-_MYSQL_VECTOR_METRIC_MAP: Final[dict[str, str]] = {"euclidean": "EUCLIDEAN", "cosine": "COSINE", "inner_product": "DOT"}
-_ORACLE_VECTOR_METRIC_MAP: Final[dict[str, str]] = {
-    "euclidean": "EUCLIDEAN",
-    "cosine": "COSINE",
-    "inner_product": "DOT",
-    "euclidean_squared": "EUCLIDEAN_SQUARED",
-}
-_BIGQUERY_VECTOR_FUNCTION_MAP: Final[dict[str, str]] = {
-    "euclidean": "EUCLIDEAN_DISTANCE",
-    "cosine": "COSINE_DISTANCE",
-    "inner_product": "DOT_PRODUCT",
-}
-_DUCKDB_VECTOR_FUNCTION_MAP: Final[dict[str, str]] = {
-    "euclidean": "array_distance",
-    "cosine": "array_cosine_distance",
-    "inner_product": "array_negative_inner_product",
-}
 
 
 def is_vector_distance_expression(expression: object) -> bool:
@@ -108,7 +90,9 @@ def VectorDistance(*, this: exp.Expr, expression: exp.Expr, metric: Any = "eucli
 
 def render_vector_distance_postgres(left: str, right: str, metric: str) -> str:
     """Render PostgreSQL pgvector operator syntax."""
-    operator = _POSTGRES_VECTOR_OPERATOR_MAP.get(metric)
+    operator_map = {"euclidean": "<->", "cosine": "<=>", "inner_product": "<#>"}
+
+    operator = operator_map.get(metric)
     if operator:
         return f"{left} {operator} {right}"
 
@@ -117,7 +101,9 @@ def render_vector_distance_postgres(left: str, right: str, metric: str) -> str:
 
 def render_vector_distance_mysql(left: str, right: str, metric: str) -> str:
     """Render MySQL DISTANCE function syntax."""
-    mysql_metric = _MYSQL_VECTOR_METRIC_MAP.get(metric, "EUCLIDEAN")
+    metric_map = {"euclidean": "EUCLIDEAN", "cosine": "COSINE", "inner_product": "DOT"}
+
+    mysql_metric = metric_map.get(metric, "EUCLIDEAN")
 
     if ("ARRAY" in right or "[" in right) and "STRING_TO_VECTOR" not in right:
         right = f"STRING_TO_VECTOR({right})"
@@ -127,7 +113,14 @@ def render_vector_distance_mysql(left: str, right: str, metric: str) -> str:
 
 def render_vector_distance_oracle(left: str, right: str, metric: str) -> str:
     """Render Oracle VECTOR_DISTANCE function syntax."""
-    oracle_metric = _ORACLE_VECTOR_METRIC_MAP.get(metric, "EUCLIDEAN")
+    metric_map = {
+        "euclidean": "EUCLIDEAN",
+        "cosine": "COSINE",
+        "inner_product": "DOT",
+        "euclidean_squared": "EUCLIDEAN_SQUARED",
+    }
+
+    oracle_metric = metric_map.get(metric, "EUCLIDEAN")
 
     if ("[" in right or "ARRAY" in right) and "TO_VECTOR" not in right:
         right = f"TO_VECTOR({right})"
@@ -137,7 +130,9 @@ def render_vector_distance_oracle(left: str, right: str, metric: str) -> str:
 
 def render_vector_distance_bigquery(left: str, right: str, metric: str) -> str:
     """Render BigQuery vector distance function syntax."""
-    function_name = _BIGQUERY_VECTOR_FUNCTION_MAP.get(metric)
+    function_map = {"euclidean": "EUCLIDEAN_DISTANCE", "cosine": "COSINE_DISTANCE", "inner_product": "DOT_PRODUCT"}
+
+    function_name = function_map.get(metric)
     if function_name:
         return f"{function_name}({left}, {right})"
 
@@ -146,7 +141,12 @@ def render_vector_distance_bigquery(left: str, right: str, metric: str) -> str:
 
 def render_vector_distance_duckdb(left: str, right: str, metric: str, *, dimension: int | None = None) -> str:
     """Render DuckDB VSS extension function syntax."""
-    function_name = _DUCKDB_VECTOR_FUNCTION_MAP.get(metric)
+    function_map = {
+        "euclidean": "array_distance",
+        "cosine": "array_cosine_distance",
+        "inner_product": "array_negative_inner_product",
+    }
+    function_name = function_map.get(metric)
     if function_name:
         target_type = f"DOUBLE[{dimension}]" if dimension is not None else "DOUBLE[]"
         return f"{function_name}({left}, CAST({right} AS {target_type}))"