snowflake-sqlalchemy 1.10.0__tar.gz → 1.10.2__tar.gz

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/.pre-commit-config.yaml

@@ -1,7 +1,9 @@
 exclude: '^(.*egg.info.*|.*/parameters.py).*$'
+default_language_version:
+    python: python3
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v6.0.0
     hooks:
     -   id: trailing-whitespace
         exclude: '\.ambr$'
@@ -14,19 +16,21 @@ repos:
     hooks:
         - id: isort
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.15.1
+    rev: v3.18.0
     hooks:
     -   id: pyupgrade
         args: [--py37-plus]
 -   repo: https://github.com/psf/black
-    rev: 24.2.0
+    rev: 24.10.0
     hooks:
         - id: black
           args:
               - --safe
+              - --target-version
+              - py38
           language_version: python3
 -   repo: https://github.com/Lucas-C/pre-commit-hooks.git
-    rev: v1.5.5
+    rev: v1.5.6
     hooks:
     -   id: insert-license
         name: insert-py-license
@@ -40,7 +44,7 @@ repos:
             - --license-filepath
             - license_header.txt
 -   repo: https://github.com/pycqa/flake8
-    rev: 7.0.0
+    rev: 7.3.0
     hooks:
       - id: flake8
         additional_dependencies:

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/DESCRIPTION.md

@@ -11,6 +11,13 @@ Source code is also available at:
 
 # Release Notes
 
+- v1.10.2 (June 18, 2026)
+- Fix double-escaped identifier quoting for database-qualified schemas in `_StructuredTypeInfoManager.get_table_columns`. Since v1.10.1 the schema was quoted as a single identifier, so a qualified schema such as `"MYDB"."MYSCHEMA"` became `"""MYDB"".""MYSCHEMA"""` and the `DESC TABLE` fallback failed (emitting a `Failed to reflect table ... sqlalchemy:_get_schema_columns` warning) for every structured-typed table when reflecting a non-default `database.schema`. The schema is now split on the dot and each component is double-quoted individually, preserving the SNOW-3480955 injection guard while correctly handling qualified schemas.
+
+- v1.10.1 (June 15, 2026)
+  - Fix `regexp_match` and `regexp_replace` flags rendered as bound parameters instead of literal strings ([#SNOW-3573046](https://github.com/snowflakedb/snowflake-sqlalchemy)). Flags passed to `ColumnElement.regexp_match(..., flags=...)` and `ColumnElement.regexp_replace(..., flags=...)` were processed through the standard parameter pipeline, producing incorrect SQL. Flags are now rendered as inline string literals, matching Snowflake's expected `REGEXP_LIKE(col, pattern, 'i')` / `REGEXP_REPLACE(col, pattern, replacement, 'i')` syntax.
+  - Fix inconsistent identifier quoting in `_StructuredTypeInfoManager.get_table_columns`. The `DESC TABLE` fallback path used raw denormalised names in an f-string while all other reflection paths apply `ip.quote(denormalize_name(...))` via `_always_quote_join`. Schema and table components are now consistently double-quoted before the statement is constructed, and the method delegates to `get_table_columns_by_full_name` to collapse the two previously divergent code paths.
+
 - v1.10.0 (May 20, 2026)
   - Fix `with_loader_criteria` silently dropping filters on non-Snowflake dialects ([#676](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/676)). Importing `snowflake-sqlalchemy` previously altered SQLAlchemy's ORM compilation for every dialect in the process, causing loader-criteria filters to be omitted inside sealed subqueries when using PostgreSQL, MySQL, SQLite, etc. Snowflake dialect behavior is unchanged; the BCR-1057 lateral-join workaround is now scoped to Snowflake connections only.
   - Map Snowflake `UUID` column type to `sqlalchemy.sql.sqltypes.UUID` for reflection on SQLAlchemy 2.x ([#681](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/681)). Previously reflected as `NullType`. Values are returned as plain strings (`as_uuid=False`) rather than `uuid.UUID` instances. No change on SQLAlchemy 1.4 where the generic `UUID` type does not exist.

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.10.0
+Version: 1.10.2
 Summary: Snowflake SQLAlchemy Dialect
 Project-URL: Changelog, https://github.com/snowflakedb/snowflake-sqlalchemy/blob/main/DESCRIPTION.md
 Project-URL: Documentation, https://docs.snowflake.com/en/user-guide/sqlalchemy.html

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/ci/build.sh

@@ -3,7 +3,7 @@
 # Build snowflake-sqlalchemy
 set -o pipefail
 
-PYTHON="python3.8"
+PYTHON="python3.9"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 DIST_DIR="${SQLALCHEMY_DIR}/dist"

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/ci/test_docker.sh

@@ -7,7 +7,7 @@
 set -o pipefail
 
 # In case this is ran from dev-vm
-PYTHON_ENV=${1:-3.8}
+PYTHON_ENV=${1:-3.9}
 
 # Set constants
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/ci/test_linux.sh

@@ -6,7 +6,7 @@
 #   - This script assumes that ../dist/repaired_wheels has the wheel(s) built for all versions to be tested
 #   - This is the script that test_docker.sh runs inside of the docker container
 
-PYTHON_VERSIONS="${1:-3.8 3.9 3.10 3.11 3.12 3.13 3.14}"
+PYTHON_VERSIONS="${1:-3.9 3.10 3.11 3.12 3.13 3.14}"
 # Python versions where pyarrow (required by pandas extra) is not available
 PANDAS_SKIP_VERSIONS="3.14"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/base.py

@@ -152,7 +152,7 @@ class SnowflakeSelectState(SelectState):
                     raw_columns, left, right, onclause
                 )
             else:
-                (replace_from_obj_index) = self._join_place_explicit_left_side(left)
+                replace_from_obj_index = self._join_place_explicit_left_side(left)
 
             if replace_from_obj_index is not None:
                 # splice into an existing element in the
@@ -793,7 +793,7 @@ class SnowflakeCompiler(compiler.SQLCompiler):
         pattern = self.process(binary.right, **kw)
         flags = binary.modifiers["flags"]
         if flags is not None:
-            flags = self.process(flags, **kw)
+            flags = self.render_literal_value(flags, sqltypes.STRINGTYPE)
         return string, pattern, flags
 
     def visit_regexp_match_op_binary(self, binary, operator, **kw):

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/custom_types.py

@@ -86,7 +86,7 @@ class VECTOR(SnowflakeType):
 
     @staticmethod
     def _map_sqlalchemy_type(
-        element_type: Union[sqltypes.Integer, sqltypes.Float]
+        element_type: Union[sqltypes.Integer, sqltypes.Float],
     ) -> str:
         if isinstance(element_type, sqltypes.Integer):
             return "INT"

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/exc.py

@@ -26,14 +26,14 @@ class UnsupportedPrimaryKeysAndForeignKeysError(ArgumentError):
 
 
 class RequiredParametersNotProvidedError(ArgumentError):
-    def __init__(self, target: str, parameters: List[str]):
+    def __init__(self, target: str, parameters: List[str]):  # noqa: B042
         super().__init__(
             f"{target} requires the following parameters: %s." % ", ".join(parameters)
         )
 
 
 class UnexpectedTableOptionKeyError(ArgumentError):
-    def __init__(self, expected: str, actual: str):
+    def __init__(self, expected: str, actual: str):  # noqa: B042
         super().__init__(f"Expected table option {expected} but got {actual}.")
 
 
@@ -45,7 +45,9 @@ class OptionKeyNotProvidedError(ArgumentError):
 
 
 class UnexpectedOptionParameterTypeError(ArgumentError):
-    def __init__(self, parameter_name: str, target: str, types: List[str]):
+    def __init__(  # noqa: B042
+        self, parameter_name: str, target: str, types: List[str]
+    ):
         super().__init__(
             f"Parameter {parameter_name} of {target} requires to be one"
             f" of following types: {', '.join(types)}."
@@ -67,7 +69,9 @@ class UnexpectedOptionTypeError(ArgumentError):
 
 
 class InvalidTableParameterTypeError(ArgumentError):
-    def __init__(self, name: str, input_type: str, expected_types: List[str]):
+    def __init__(  # noqa: B042
+        self, name: str, input_type: str, expected_types: List[str]
+    ):
         expected_types_str = "', '".join(expected_types)
         super().__init__(
             f"Invalid parameter type '{input_type}' provided for '{name}'. "
@@ -76,7 +80,7 @@ class InvalidTableParameterTypeError(ArgumentError):
 
 
 class MultipleErrors(ArgumentError):
-    def __init__(self, errors):
+    def __init__(self, errors):  # noqa: B042
         self.errors = errors
 
     def __str__(self):
@@ -84,7 +88,9 @@ class MultipleErrors(ArgumentError):
 
 
 class StructuredTypeNotSupportedInTableColumnsError(ArgumentError):
-    def __init__(self, table_type: str, table_name: str, column_name: str):
+    def __init__(  # noqa: B042
+        self, table_type: str, table_name: str, column_name: str
+    ):
         super().__init__(
             f"Column '{column_name}' is of a structured type, which is only supported on Iceberg tables. "
             f"The table '{table_name}' is of type '{table_type}', not Iceberg."

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/name_utils.py

@@ -1,6 +1,9 @@
 #
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 
+import operator
+from functools import reduce
+
 from sqlalchemy.sql.compiler import IdentifierPreparer
 from sqlalchemy.sql.elements import quoted_name
 
@@ -61,3 +64,42 @@ class _NameUtils:
         ):
             name = name.upper()
         return name
+
+    def _quote_component(self, component) -> str:
+        """Unconditionally double-quote a single pre-split identifier component.
+
+        Components marked ``quote=True`` are taken verbatim (case preserved);
+        others are denormalized first so a plain lowercase name maps to the
+        Snowflake-stored uppercase form.
+
+        Use this only for parts that were already extracted by
+        ``_split_schema_by_dot`` — do NOT call it on dotted strings because
+        it will not split them first.
+        """
+        ip = self.identifier_preparer
+        name = str(component)
+        if getattr(component, "quote", None):
+            return ip.quote_identifier(name)
+        return ip.quote_identifier(self.denormalize_name(name))
+
+    def always_quote_join(self, *idents) -> str:
+        """Build a dot-joined SQL identifier string that always quotes every part.
+
+        Each identifier in *idents is split on unquoted dots via
+        ``_split_schema_by_dot`` (so ``"db.schema"`` becomes two components),
+        then every component is unconditionally double-quoted via
+        ``_quote_component``.
+
+        Do NOT pass pre-split parts that may contain literal dots (e.g. a
+        component extracted from ``'"my.schema"'``).  Use ``_quote_component``
+        directly on each pre-split part instead.
+        """
+        split_idents = reduce(
+            operator.add,
+            [
+                self.identifier_preparer._split_schema_by_dot(ids)
+                for ids in idents
+                if ids is not None
+            ],
+        )
+        return ".".join(self._quote_component(i) for i in split_idents)

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/snowdialect.py

@@ -354,28 +354,11 @@ class SnowflakeDialect(default.DefaultDialect):
     def _always_quote_join(self, *idents):
         """Build a dot-joined identifier string that always quotes every part.
 
-        Unlike _denormalize_quote_join (which quotes only when _requires_quotes
-        demands it), this helper denormalizes each segment first and then
-        unconditionally wraps it in double-quotes.  This is safe because quoting
-        a denormalized Snowflake identifier is semantically equivalent to the
-        unquoted form for case-insensitive names, while also being correct for
-        case-sensitive ones.
-
-        IMPORTANT: denormalization must happen before quoting.  Quoting the
-        SA-normalized (lowercase) form would produce "my_table" which Snowflake
-        resolves as a case-sensitive reference to a table literally stored as
-        my_table — different from the stored MY_TABLE.
-
-        Only use this for new, single-table SQL helpers.  Existing callers of
-        _denormalize_quote_join must not be changed to avoid altering SQL output
-        for existing users (backward-compatibility constraint).
+        Delegates to ``_NameUtils.always_quote_join`` — see that method for
+        the full contract.  The dialect accessor exists for backward
+        compatibility with callers inside this class.
         """
-        ip = self.identifier_preparer
-        split_idents = reduce(
-            operator.add,
-            [ip._split_schema_by_dot(ids) for ids in idents if ids is not None],
-        )
-        return ".".join(ip.quote(self.denormalize_name(i)) for i in split_idents)
+        return self.name_utils.always_quote_join(*idents)
 
     def _get_full_schema_name(self, connection, schema=None, **kw):
         """
@@ -407,24 +390,10 @@ class SnowflakeDialect(default.DefaultDialect):
                     f"'database.schema', got {len(parts)} parts"
                 )
 
-        # Quote each part unconditionally and preserve explicit quoted-name
-        # boundaries from _split_schema_by_dot. Do NOT pass through
-        # _denormalize_quote_join, which would re-split parts containing
-        # literal dots (e.g. "schema.with.dots").
-        quoted_parts = []
-        for part in parts:
-            part_name = str(part)
-            if getattr(part, "quote", None):
-                quoted_parts.append(
-                    self.identifier_preparer.quote_identifier(part_name)
-                )
-            else:
-                quoted_parts.append(
-                    self.identifier_preparer.quote_identifier(
-                        self.denormalize_name(part_name)
-                    )
-                )
-        return ".".join(quoted_parts)
+        # Quote each pre-split part unconditionally, preserving explicit
+        # quoted-name boundaries.  Do NOT re-split via always_quote_join
+        # because parts may contain literal dots (e.g. "schema.with.dots").
+        return ".".join(self.name_utils._quote_component(p) for p in parts)
 
     @reflection.cache
     def _current_database_schema(self, connection, **kw):

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/sql/custom_schema/options/as_query_option.py

@@ -29,7 +29,7 @@ class AsQueryOption(TableOption):
 
     @staticmethod
     def create(
-        value: Optional[Union["AsQueryOption", str, Selectable]]
+        value: Optional[Union["AsQueryOption", str, Selectable]],
     ) -> "TableOption":
         if isinstance(value, (NoneType, AsQueryOption)):
             return value

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/sql/custom_schema/options/target_lag_option.py

@@ -52,7 +52,7 @@ class TargetLagOption(TableOption):
 
     @staticmethod
     def create(
-        value: Union["TargetLagOption", Tuple[int, TimeUnit], KeywordOptionType]
+        value: Union["TargetLagOption", Tuple[int, TimeUnit], KeywordOptionType],
     ) -> Optional[TableOption]:
         if isinstance(value, NoneType):
             return value

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/structured_type_info_manager.py

@@ -84,18 +84,12 @@ class _StructuredTypeInfoManager:
         schema = schema if schema else self.default_schema
 
         if "." in str(table_name):
-            parts = self.name_utils.identifier_preparer._split_schema_by_dot(
-                str(table_name)
-            )
-            table_name = str(parts[-1])
+            ip = self.name_utils.identifier_preparer
+            table_name = ip._split_schema_by_dot(str(table_name))[-1]
 
-        table_schema = self.name_utils.denormalize_name(schema)
-        table_name = self.name_utils.denormalize_name(table_name)
-        result = self._execute_desc(f"{table_schema}.{table_name}")
-        if not result:
-            return []
-
-        return self._parse_desc_result(result)
+        return self.get_table_columns_by_full_name(
+            self.name_utils.always_quote_join(schema, table_name)
+        )
 
     def _parse_desc_result(self, result):
         """Parse DESC TABLE result into column information"""

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/src/snowflake/sqlalchemy/version.py

@@ -3,4 +3,4 @@
 #
 # Update this for the versions
 # Don't change the forth version number from None
-VERSION = "1.10.0"
+VERSION = "1.10.2"

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/tests/test_compiler.py

@@ -125,6 +125,34 @@ class TestSnowflakeCompiler(AssertsCompiledSQL):
             "SELECT table1.name FROM table1 WHERE table1.name NOT ILIKE %(name_1)s ESCAPE '\\\\'",
         )
 
+    def test_regexp_match_with_flags_compilation(self):
+        statement = select(table1.c.name).where(
+            table1.c.name.regexp_match("ann", flags="i")
+        )
+        self.assert_compile(
+            statement,
+            "SELECT table1.name FROM table1 WHERE REGEXP_LIKE(table1.name, %(name_1)s, 'i')",
+            dialect="snowflake",
+        )
+
+    def test_not_regexp_match_with_flags_compilation(self):
+        statement = select(table1.c.name).where(
+            ~table1.c.name.regexp_match("ann", flags="i")
+        )
+        self.assert_compile(
+            statement,
+            "SELECT table1.name FROM table1 WHERE NOT REGEXP_LIKE(table1.name, %(name_1)s, 'i')",
+            dialect="snowflake",
+        )
+
+    def test_regexp_replace_with_flags_compilation(self):
+        statement = select(table1.c.name.regexp_replace("ann", "bob", flags="i"))
+        self.assert_compile(
+            statement,
+            "SELECT REGEXP_REPLACE(table1.name, %(name_1)s, %(name_2)s, 'i') AS anon_1 FROM table1",
+            dialect="snowflake",
+        )
+
     def test_drop_table_comment(self):
         self.assert_compile(DropTableComment(table1), "COMMENT ON TABLE table1 IS ''")
         self.assert_compile(

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/tests/test_core.py

@@ -2450,7 +2450,7 @@ def test_true_division_operation(engine_testaccount, operation):
         [literal(3), literal(2), 1.5, 1.5],
         [literal(4), literal(1.5), 2.6666666666666665, 2.0],
         [literal(5.5), literal(10.7), 0.5140186915887851, 0],
-        [literal(5.5), literal(8), 0.6875, 0.6875],
+        [literal(5.5), literal(8), 0.6875, 0.0],
     ],
 )
 @pytest.mark.feature_v20

{snowflake_sqlalchemy-1.10.0 → snowflake_sqlalchemy-1.10.2}/tests/test_structured_datatypes.py

@@ -25,6 +25,7 @@ from snowflake.sqlalchemy import NUMBER, IcebergTable, SnowflakeTable
 from snowflake.sqlalchemy.custom_types import ARRAY, MAP, OBJECT, TEXT
 from snowflake.sqlalchemy.exc import StructuredTypeNotSupportedInTableColumnsError
 from snowflake.sqlalchemy.name_utils import _NameUtils
+from snowflake.sqlalchemy.snowdialect import SnowflakeDialect
 from snowflake.sqlalchemy.structured_type_info_manager import _StructuredTypeInfoManager
 
 
@@ -603,14 +604,10 @@ def test_structured_type_not_supported_in_table_columns_error(
 
 
 @patch.object(_StructuredTypeInfoManager, "_execute_desc")
-@patch.object(_NameUtils, "denormalize_name")
-def test_structured_type_on_dropped_table(
-    mocked_denormalize_name_method, mocked_execute_desc_method
-):
+def test_structured_type_on_dropped_table(mocked_execute_desc_method):
     mocked_execute_desc_method.return_value = None
-    mocked_denormalize_name_method.side_effect = lambda v: v
     structured_type_info = _StructuredTypeInfoManager(
-        None, _NameUtils(None), "mySchema"
+        None, _NameUtils(SnowflakeDialect().identifier_preparer), "mySchema"
     )
     result = structured_type_info.get_column_info(
         "mySchema", "dropped_table", "structured_type_col"
@@ -619,10 +616,7 @@ def test_structured_type_on_dropped_table(
 
 
 @patch.object(_StructuredTypeInfoManager, "_execute_desc")
-@patch.object(_NameUtils, "denormalize_name")
-def test_structured_type_on_table_with_map(
-    mocked_denormalize_name_method, mocked_execute_desc_method
-):
+def test_structured_type_on_table_with_map(mocked_execute_desc_method):
     mocked_execute_desc_method.return_value = [
         [
             "myCol",
@@ -637,9 +631,8 @@ def test_structured_type_on_table_with_map(
             "MapColumn",
         ]
     ]
-    mocked_denormalize_name_method.side_effect = lambda v: v
     structured_type_info = _StructuredTypeInfoManager(
-        None, _NameUtils(None), "mySchema"
+        None, _NameUtils(SnowflakeDialect().identifier_preparer), "mySchema"
     )
     result = structured_type_info.get_column_info("mySchema", "dropped_table", "myCol")
     assert result is not None

snowflake_sqlalchemy-1.10.2/tests/test_unit_name_utils.py

@@ -0,0 +1,144 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+"""
+Unit tests for _NameUtils._quote_component and _NameUtils.always_quote_join.
+
+These methods are the canonical always-quote helpers shared by
+SnowflakeDialect._always_quote_join, _get_full_schema_name, and
+_StructuredTypeInfoManager.get_table_columns.  Correctness here guarantees
+all three callers stay consistent automatically.
+"""
+
+import re
+
+import pytest
+from sqlalchemy.sql.elements import quoted_name
+
+from snowflake.sqlalchemy.name_utils import _NameUtils
+from snowflake.sqlalchemy.snowdialect import SnowflakeDialect
+
+
+@pytest.fixture
+def nu():
+    return _NameUtils(SnowflakeDialect().identifier_preparer)
+
+
+# ---------------------------------------------------------------------------
+# _quote_component
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "component, expected",
+    [
+        pytest.param(
+            quoted_name("myschema", None), '"MYSCHEMA"', id="lowercase→uppercase"
+        ),
+        pytest.param(quoted_name("MYSCHEMA", None), '"MYSCHEMA"', id="uppercase"),
+        pytest.param(quoted_name("MySchema", None), '"MySchema"', id="mixed-case"),
+        pytest.param(
+            quoted_name("myschema", True),
+            '"myschema"',
+            id="quote=True preserves lowercase",
+        ),
+        pytest.param(
+            quoted_name("MySchema", True),
+            '"MySchema"',
+            id="quote=True preserves mixed-case",
+        ),
+    ],
+)
+def test_quote_component(nu, component, expected):
+    assert nu._quote_component(component) == expected
+
+
+def test_quote_component_escapes_internal_double_quote(nu):
+    result = nu._quote_component(quoted_name('my"schema', None))
+    assert result.startswith('"') and result.endswith('"')
+    assert '""' in result  # SQL double-quote escaping
+
+
+# ---------------------------------------------------------------------------
+# always_quote_join
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "idents, expected",
+    [
+        # plain identifiers
+        pytest.param(
+            ("myschema", "mytable"), '"MYSCHEMA"."MYTABLE"', id="plain lowercase"
+        ),
+        pytest.param(
+            ("MYSCHEMA", "MYTABLE"), '"MYSCHEMA"."MYTABLE"', id="plain uppercase"
+        ),
+        pytest.param(("MySchema", "MyTable"), '"MySchema"."MyTable"', id="mixed case"),
+        pytest.param(
+            (None, "myschema", "mytable"), '"MYSCHEMA"."MYTABLE"', id="None skipped"
+        ),
+        pytest.param(("myschema",), '"MYSCHEMA"', id="single ident"),
+        # database-qualified schemas — 1.10.1 regression guard
+        pytest.param(
+            ("MYDB.MYSCHEMA", "mytable"),
+            '"MYDB"."MYSCHEMA"."MYTABLE"',
+            id="unquoted db-qualified schema",
+        ),
+        pytest.param(
+            ("mydb.myschema", "mytable"),
+            '"MYDB"."MYSCHEMA"."MYTABLE"',
+            id="lowercase db-qualified schema",
+        ),
+        pytest.param(
+            ('"MYDB"."MYSCHEMA"', "mytable"),
+            '"MYDB"."MYSCHEMA"."MYTABLE"',
+            id="pre-quoted db-qualified schema",
+        ),
+        pytest.param(
+            ('"my.schema"', "mytable"),
+            '"my.schema"."MYTABLE"',
+            id="literal dot in quoted component not split",
+        ),
+        pytest.param(
+            ("myschema", "foo.bar"),
+            '"MYSCHEMA"."FOO"."BAR"',
+            id="dot in table splits into components",
+        ),
+        # case-sensitivity signal (quote=True) preserved
+        pytest.param(
+            (quoted_name("myschema", True), "mytable"),
+            '"myschema"."MYTABLE"',
+            id="quote=True lowercase case preserved",
+        ),
+        pytest.param(
+            (quoted_name("MySchema", True), "mytable"),
+            '"MySchema"."MYTABLE"',
+            id="quote=True mixed-case preserved",
+        ),
+    ],
+)
+def test_always_quote_join(nu, idents, expected):
+    assert nu.always_quote_join(*idents) == expected
+    assert '"""' not in nu.always_quote_join(*idents)
+
+
+# ---------------------------------------------------------------------------
+# always_quote_join — identifier quoting correctness
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "idents, blocked",
+    [
+        pytest.param(
+            ("myschema; DROP TABLE users--", "mytable"), ";", id="semicolon in schema"
+        ),
+        pytest.param(("myschema", "mytable; SELECT 1--"), ";", id="semicolon in table"),
+        pytest.param(("x'; DROP TABLE t--", "t"), "DROP", id="DROP in schema"),
+    ],
+)
+def test_always_quote_join_identifier_quoting(nu, idents, blocked):
+    result = nu.always_quote_join(*idents)
+    stripped = re.sub(r'"[^"]*"', "", result)
+    assert blocked not in stripped, f"Pattern {blocked!r} escaped quoting: {result!r}"