refactor(builder): share SQL object extraction

Author: cofin

sqlspec/builder/_select.py

@@ -21,6 +21,7 @@
     _coerce_column,
     extract_column_name,
     extract_expression,
+    extract_sql_object_expression,
     parse_column_expression,
     parse_condition_expression,
     parse_order_expression,
@@ -648,16 +649,7 @@ def _normalize_subquery_expression(self, subquery: Any, builder: "SQLBuilderProt
             return subquery_expr
 
         if has_expression_and_sql(subquery):
-            self._merge_parameters(subquery)
-            expression_attr = subquery.expression
-            if isinstance(expression_attr, exp.Expr):
-                return expression_attr
-            sql_text = subquery.sql
-            parsed_from_sql: exp.Expr | None = exp.maybe_parse(sql_text, dialect=builder.dialect)
-            if parsed_from_sql is None:
-                msg = f"Could not parse subquery SQL: {sql_text}"
-                raise SQLBuilderError(msg)
-            return parsed_from_sql
+            return extract_sql_object_expression(subquery, builder=self)
 
         if isinstance(subquery, exp.Expr):
             return subquery
@@ -779,15 +771,7 @@ def _normalize_condition_expression(expression: exp.Expr) -> exp.Expr:
                 return builder._parameterize_expression(_normalize_condition_expression(raw_expr))
             return parse_condition_expression(str(condition))
         if has_expression_and_sql(condition):
-            expression_attr = condition.expression
-            if isinstance(expression_attr, exp.Expr):
-                self._merge_parameters(condition)
-                return _normalize_condition_expression(expression_attr)
-            sql_text = getattr(condition, "raw_sql", None)
-            if sql_text is None:
-                sql_text = condition.sql
-            self._merge_parameters(condition)
-            return parse_condition_expression(sql_text)
+            return _normalize_condition_expression(extract_sql_object_expression(condition, builder=self))
 
         msg = f"Unsupported condition type: {type(condition).__name__}"
         raise SQLBuilderError(msg)

tests/unit/builder/test_sql_factory.py

@@ -32,6 +32,8 @@
     StringExpression,
 )
 from sqlspec.builder._join import create_join_builder
+from sqlspec.builder import _select as select_module
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
 from sqlspec.core import SQL
 from sqlspec.exceptions import SQLBuilderError
 
@@ -982,6 +984,21 @@ def test_multiple_sql_raw_objects_parameter_merging() -> None:
     assert ":min_date" in stmt.sql
 
 
+def test_select_conditions_use_shared_expression_extraction(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = 0
+
+    def extract(value: object, builder: object | None = None) -> exp.Expr:
+        nonlocal calls
+        calls += 1
+        return extract_sql_object_expression(value, builder)
+
+    monkeypatch.setattr(select_module, "extract_sql_object_expression", extract)
+    sql.select("*").from_("users").where_exists(
+        sql.raw("SELECT 1 FROM posts WHERE posts.user_id = :user_id", user_id=1)
+    ).where(sql.raw("id = :id", id=1))
+    assert calls == 2
+
+
 def test_sql_raw_without_parameters_still_works() -> None:
     """Test that SQL objects without parameters still work correctly."""
     raw_expr = sql.raw("NOW()")