Cover IN-clause expansion at render_postcompile=True time too

The __init__ bindtemplate swap covered execute-time IN expansion but
missed two adjacent paths:

  1. compile_kwargs={'render_postcompile': True} — fires inside super's
     __init__, before a post-super subclass override can take effect.
  2. construct_expanded_state() called directly on a compiled stmt.

Both paths funnel through SQLCompiler._literal_execute_expanding_parameter,
which reads self.bindtemplate (or compilation_bindtemplate for numeric
paramstyles) once into a local variable and uses it to render every
expanded marker. Override that single method to swap both templates
to the backticked form for the duration of the super call, then
restore.

This removes the __init__ template swap entirely — the override on
_literal_execute_expanding_parameter is the single point that covers
all three expansion call sites (execute-time, render_postcompile=True
compile-time, construct_expanded_state).

Adds a regression test exercising both the render_postcompile=True
and construct_expanded_state paths.

Co-authored-by: Isaac

Author: msrathore-db

src/databricks/sqlalchemy/_ddl.py

@@ -110,24 +110,22 @@ class DatabricksStatementCompiler(compiler.SQLCompiler):
       ``bindparam_string`` via ``self.process(statement)``. Oracle
       overrides this same method (``cx_oracle.py:781``) to quote-wrap
       names, and we do the same here.
-    * **Execute-time IN expansion** — SQLAlchemy's
+    * **IN-clause expansion** — SQLAlchemy's
       ``_literal_execute_expanding_parameter`` builds expanded markers
       (``:col-name_1, :col-name_2, ...``) directly from
-      ``self.bindtemplate``, bypassing ``bindparam_string``. We swap
-      ``bindtemplate`` after super's ``__init__`` to ensure that path
-      also emits backticked markers.
+      ``self.bindtemplate``, bypassing ``bindparam_string``. This method
+      is called from three sites: at execute time
+      (``default.py::_execute_context``), during compile time when the
+      user passes ``compile_kwargs={'render_postcompile': True}``, and
+      from ``construct_expanded_state``. We intercept by overriding the
+      method itself rather than swapping ``bindtemplate`` in
+      ``__init__``, because the ``render_postcompile=True`` path fires
+      inside super's own ``__init__`` — before a subclass ``__init__``
+      post-super override would take effect.
     """
 
     _BACKTICKED_BIND_TEMPLATE = ":`%(name)s`"
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # Super sets self.bindtemplate from BIND_TEMPLATES[paramstyle]
-        # near the end of its __init__ (for execute-time use, including
-        # IN-clause expansion). Override it here so the expansion path
-        # renders backticked markers too.
-        self.bindtemplate = self._BACKTICKED_BIND_TEMPLATE
-
     def bindparam_string(self, name, **kw):
         # Fall through to super for the specialized render paths it
         # already handles (POSTCOMPILE placeholder; escape-map translation
@@ -154,6 +152,28 @@ def bindparam_string(self, name, **kw):
                 ret = self.render_bind_cast(bindparam_type, type_impl, ret)
         return ret
 
+    def _literal_execute_expanding_parameter(self, name, parameter, values):
+        # Super reads ``self.bindtemplate`` (or ``compilation_bindtemplate``
+        # for numeric paramstyles) once into a local variable and uses it to
+        # render every expanded marker. Swap both to our backticked template
+        # for the duration of the call, then restore, so any later read sees
+        # the original values. This covers execute-time expansion, the
+        # ``render_postcompile=True`` compile-kwarg path that fires inside
+        # super's ``__init__``, and ``construct_expanded_state``.
+        saved_bt = getattr(self, "bindtemplate", None)
+        saved_cbt = getattr(self, "compilation_bindtemplate", None)
+        self.bindtemplate = self._BACKTICKED_BIND_TEMPLATE
+        self.compilation_bindtemplate = self._BACKTICKED_BIND_TEMPLATE
+        try:
+            return super()._literal_execute_expanding_parameter(
+                name, parameter, values
+            )
+        finally:
+            if saved_bt is not None:
+                self.bindtemplate = saved_bt
+            if saved_cbt is not None:
+                self.compilation_bindtemplate = saved_cbt
+
     def limit_clause(self, select, **kw):
         """Identical to the default implementation of SQLCompiler.limit_clause except it writes LIMIT ALL instead of LIMIT -1,
         since Databricks SQL doesn't support the latter.

tests/test_local/test_ddl.py

@@ -337,19 +337,50 @@ def test_multivalues_insert_disambiguates_with_backticked_markers(self):
         assert ":`col-name_m0`" in sql
         assert ":`col-name_m1`" in sql
 
-    def test_in_clause_with_hyphenated_column_falls_through_to_postcompile(self):
-        """IN clauses use ``post_compile`` params which our override skips
-        (the rendered ``__[POSTCOMPILE_...]`` marker is not a bind name).
-        The anonymized bind SQLAlchemy assigns to the IN parameter does
-        still get backticked because it contains a hyphen (``col_name_1``
-        would be fine, but the column name slug can leak hyphens).
+    def test_in_clause_with_hyphenated_column_compiles_to_postcompile(self):
+        """The initial compilation leaves an IN clause as a POSTCOMPILE
+        placeholder. The placeholder itself isn't a bind marker so no
+        quoting is needed at this stage — the actual expanded markers
+        (``:\\`col-name_1_1\\``, …) are rendered at expansion time by our
+        ``_literal_execute_expanding_parameter`` override (see
+        ``test_in_clause_expansion_renders_backticked_markers``).
         """
         from sqlalchemy import select
 
         metadata = MetaData()
         table = Table("t", metadata, Column("col-name", String()))
         stmt = select(table).where(table.c["col-name"].in_(["a", "b"]))
+        sql = str(stmt.compile(bind=self.engine))
+        assert "POSTCOMPILE_col-name_1" in sql
+
+    def test_in_clause_expansion_renders_backticked_markers(self):
+        """Exercise the three sites that invoke
+        ``_literal_execute_expanding_parameter``:
+
+        * normal execute-time expansion via ``construct_expanded_state``
+        * ``compile_kwargs={'render_postcompile': True}`` — which fires
+          inside super's ``__init__``, before any post-super subclass
+          init would take effect
+        """
+        from sqlalchemy import select
+
+        metadata = MetaData()
+        table = Table("t", metadata, Column("col-name", String()))
+        stmt = select(table).where(table.c["col-name"].in_(["a", "b", "c"]))
+
+        # (1) render_postcompile=True at compile time — fires inside super __init__
+        rendered = str(
+            stmt.compile(bind=self.engine, compile_kwargs={"render_postcompile": True})
+        )
+        assert ":`col-name_1_1`" in rendered
+        assert ":`col-name_1_2`" in rendered
+        assert ":`col-name_1_3`" in rendered
+
+        # (2) construct_expanded_state at execute time
         compiled = stmt.compile(bind=self.engine)
-        # The POSTCOMPILE marker goes through super() — just make sure we
-        # didn't crash and the SQL is well-formed.
-        assert "POSTCOMPILE" in str(compiled) or "IN (" in str(compiled)
+        expanded = compiled.construct_expanded_state(
+            {"col-name_1": ["a", "b", "c"]}
+        )
+        assert ":`col-name_1_1`" in expanded.statement
+        assert ":`col-name_1_2`" in expanded.statement
+        assert ":`col-name_1_3`" in expanded.statement