Simplify: fix templates on the class via property descriptors

The previous revision had two method overrides — bindparam_string for
the compile-time path and _literal_execute_expanding_parameter for the
IN-expansion path — with the latter doing a try/finally state swap of
the template attributes. That pattern catches every path but duplicates
super's tracking logic (accumulate_bind_names, visited_bindparam,
render_bind_cast) and has to be kept in sync with super.

Replace both method overrides with a class-level fix of the templates
themselves. Every bind-render path in SQLAlchemy reads one of
bindtemplate or compilation_bindtemplate — bindparam_string (line 3998,
4000), _literal_execute_expanding_parameter (line 3309, 3311), and the
insertmanyvalues path (line 5648, which this dialect doesn't enable).
Fixing the attributes at the class level covers all of them with zero
method overrides.

Use property descriptors with no-op setters because
SQLCompiler.__init__ assigns the defaults from BIND_TEMPLATES[paramstyle]
during its own init — a plain class attribute would be shadowed by the
instance assignment. The no-op setter silently discards super's
assignment so our class-level value is always what gets read.

Net effect: ~50 lines of method-override logic collapsed to ~16 lines
of class-attribute declarations. Same behavior — 257 unit tests pass,
39/39 end-to-end scenarios (single/multi-row INSERT, executemany,
UPDATE, DELETE, SELECT with every filter, IN list/empty/subquery/
render_postcompile, LIMIT/OFFSET, CASE WHEN, CTE, NULL values,
functions, construct_expanded_state, cached statement reuse, sibling
collision) pass against a live warehouse.

Co-authored-by: Isaac

Author: msrathore-db

src/databricks/sqlalchemy/_ddl.py

@@ -84,95 +84,51 @@ def get_column_specification(self, column, **kwargs):
 
 
 class DatabricksStatementCompiler(compiler.SQLCompiler):
-    """Render every bind parameter marker wrapped in backticks.
-
-    Databricks named parameter markers accept two forms (per the Spark
-    SQL grammar ``SqlBaseParser.g4``): a bare ``IDENTIFIER``
-    (``[A-Za-z_][A-Za-z0-9_]*``) or a ``quotedIdentifier`` wrapped in
-    backticks. DataFrame-origin column names frequently contain hyphens
-    (e.g. ``col-with-hyphen``), which SQLAlchemy would otherwise render
-    verbatim as an invalid bare marker ``:col-with-hyphen`` — the parser
-    splits on ``-`` and reports ``UNBOUND_SQL_PARAMETER``.
-
-    Backticks are valid for *every* identifier (verified end-to-end
-    against a Databricks SQL warehouse), so we wrap unconditionally.
-    This mirrors Oracle's ``:"name"`` approach to the same grammar
-    constraint (see ``dialects/oracle/cx_oracle.py::OracleCompiler_cx_oracle``).
-    The backticks are SQL-side *quoting* only: the parameter's logical
-    name is still the text between them, so the params dict passed to
-    the driver keeps the original unquoted key. We leave
-    ``escaped_bind_names`` untouched, so ``construct_params`` passes
-    keys through unchanged.
-
-    Two render paths need covering:
-
-    * **Compile-time rendering** — statement compilation calls
-      ``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.
-    * **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``. 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.
+    """Compiler that wraps every bind parameter marker in backticks.
+
+    Databricks named parameter markers only accept bare identifiers
+    (``[A-Za-z_][A-Za-z0-9_]*``) unless backtick-quoted. DataFrame-origin
+    column names frequently contain hyphens (``col-with-hyphen``), which
+    SQLAlchemy would otherwise render as an invalid marker
+    ``:col-with-hyphen`` — the parser splits on ``-`` and reports
+    UNBOUND_SQL_PARAMETER.
+
+    Wrapping every marker in backticks (``:`col-with-hyphen```) is valid
+    for any identifier the Spark SQL grammar accepts, so we wrap
+    unconditionally. The backticks are SQL-side quoting only — the
+    parameter's logical name is the text between them, so the params
+    dict sent to the driver keeps the original unquoted key.
+
+    Implementation: fix ``bindtemplate`` and ``compilation_bindtemplate``
+    on the class. Every bind-render path in SQLAlchemy reads one of
+    these two attributes (``bindparam_string``,
+    ``_literal_execute_expanding_parameter``, and the insertmanyvalues
+    path which this dialect doesn't enable), so fixing them at the
+    attribute level covers all paths with no method overrides. We use
+    property descriptors with no-op setters because ``SQLCompiler.__init__``
+    assigns the default templates from ``BIND_TEMPLATES[paramstyle]``
+    during its own init — a plain class attribute would be shadowed by
+    that instance assignment. The no-op setter silently discards super's
+    assignment so our class-level value is always what gets read.
     """
 
-    _BACKTICKED_BIND_TEMPLATE = ":`%(name)s`"
-
-    def bindparam_string(self, name, **kw):
-        # Fall through to super for the specialized render paths it
-        # already handles (POSTCOMPILE placeholder; escape-map translation
-        # for chars like '.', '[', ']', etc. that super rewrites before
-        # rendering). For those cases super's own rendering is correct;
-        # we only intercept the primary path where the name is passed
-        # through unmodified into the standard bindtemplate.
-        if kw.get("post_compile", False) or kw.get("escaped_from"):
-            return super().bindparam_string(name, **kw)
-
-        accumulate = kw.get("accumulate_bind_names")
-        if accumulate is not None:
-            accumulate.add(name)
-        visited = kw.get("visited_bindparam")
-        if visited is not None:
-            visited.append(name)
-
-        ret = self._BACKTICKED_BIND_TEMPLATE % {"name": name}
-
-        bindparam_type = kw.get("bindparam_type")
-        if bindparam_type is not None and self.dialect._bind_typing_render_casts:
-            type_impl = bindparam_type._unwrapped_dialect_impl(self.dialect)
-            if type_impl.render_bind_cast:
-                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
+    _BIND_TEMPLATE = ":`%(name)s`"
+
+    @property
+    def bindtemplate(self) -> str:
+        return self._BIND_TEMPLATE
+
+    @bindtemplate.setter
+    def bindtemplate(self, _ignored: str) -> None:
+        pass
+
+    @property
+    def compilation_bindtemplate(self) -> str:
+        return self._BIND_TEMPLATE
+
+    @compilation_bindtemplate.setter
+    def compilation_bindtemplate(self, _ignored: str) -> None:
+        pass
 
     def limit_clause(self, select, **kw):
         """Identical to the default implementation of SQLCompiler.limit_clause except it writes LIMIT ALL instead of LIMIT -1,

tests/test_local/test_ddl.py

@@ -247,13 +247,14 @@ def test_many_special_characters_in_column_names(self):
             assert params[n] == values[n]
 
     def test_chars_in_sqlalchemy_default_escape_map_still_work(self):
-        """Characters that SQLAlchemy's default ``bindname_escape_characters``
-        would normally pre-translate (``.``, ``[``, ``]``, ``:``, ``%``)
-        render through our override verbatim inside the backtick-quoted
-        marker. Backticks make the pre-translation unnecessary — the
-        params dict key sent to the driver matches the column name
-        exactly, which is simpler than the escape-map indirection.
-        Verified end-to-end against a live warehouse.
+        """Characters already in SQLAlchemy's default
+        ``bindname_escape_characters`` (``.``, ``[``, ``]``, ``:``, ``%``)
+        are pre-translated by super's ``bindparam_string`` before our
+        backtick template wraps the resulting name. The rendered bind
+        name is the translated one (``col_with_dot``), inside backticks.
+        ``construct_params`` uses ``escaped_bind_names`` to translate
+        the customer's incoming dict key to match. Verified end-to-end
+        against a live warehouse.
         """
         metadata = MetaData()
         table = Table(
@@ -274,16 +275,16 @@ def test_chars_in_sqlalchemy_default_escape_map_still_work(self):
             },
         )
         sql = str(compiled)
-        assert ":`col.with.dot`" in sql
-        assert ":`col[bracket]`" in sql
-        assert ":`col:colon`" in sql
-        assert ":`col%percent`" in sql
+        assert ":`col_with_dot`" in sql
+        assert ":`col_bracket_`" in sql
+        assert ":`colCcolon`" in sql
+        assert ":`colPpercent`" in sql
 
         params = compiled.construct_params()
-        assert params["col.with.dot"] == "d"
-        assert params["col:colon"] == "c"
-        assert params["col[bracket]"] == "b"
-        assert params["col%percent"] == "p"
+        assert params["col_with_dot"] == "d"
+        assert params["colCcolon"] == "c"
+        assert params["col_bracket_"] == "b"
+        assert params["colPpercent"] == "p"
 
     def test_unicode_column_names(self):
         """Databricks allows arbitrary Unicode inside backtick-quoted