snowflake-sqlalchemy 1.7.5__tar.gz → 1.7.7__tar.gz

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/DESCRIPTION.md

@@ -7,9 +7,14 @@ Snowflake Documentation is available at:
 Source code is also available at:
 <https://github.com/snowflakedb/snowflake-sqlalchemy>
 # Unreleased Notes
-- Compiling Merge and Copy Into
 
 # Release Notes
+- v1.7.7(September 3, 2025)
+  - Fix exception for structured type columns dropped while collecting meetadata
+
+- v1.7.6(July 10, 2025)
+  - Fix get_multi_indexes issue, wrong assign of returned indexes when processing multiple indexes in a table
+
 - v1.7.5(June 20, 2025)
   - Fix compilation of Merge and Copy Into was not working
 

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.7.5
+Version: 1.7.7
 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.7.7/src/snowflake/sqlalchemy/name_utils.py

@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+from sqlalchemy.sql.compiler import IdentifierPreparer
+from sqlalchemy.sql.elements import quoted_name
+
+
+class _NameUtils:
+
+    def __init__(self, identifier_preparer: IdentifierPreparer) -> None:
+        self.identifier_preparer = identifier_preparer
+
+    def normalize_name(self, name):
+        if name is None:
+            return None
+        if name == "":
+            return ""
+        if name.upper() == name and not self.identifier_preparer._requires_quotes(
+            name.lower()
+        ):
+            return name.lower()
+        elif name.lower() == name:
+            return quoted_name(name, quote=True)
+        else:
+            return name
+
+    def denormalize_name(self, name):
+        if name is None:
+            return None
+        if name == "":
+            return ""
+        elif name.lower() == name and not self.identifier_preparer._requires_quotes(
+            name.lower()
+        ):
+            name = name.upper()
+        return name

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/src/snowflake/sqlalchemy/parser/custom_type_parser.py

@@ -2,9 +2,8 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 from typing import List
 
-import sqlalchemy.types as sqltypes
-from sqlalchemy.sql.type_api import TypeEngine
-from sqlalchemy.types import (
+import sqlalchemy.sql.sqltypes as sqltypes
+from sqlalchemy.sql.sqltypes import (
     BIGINT,
     BINARY,
     BOOLEAN,
@@ -21,6 +20,7 @@ from sqlalchemy.types import (
     VARCHAR,
     NullType,
 )
+from sqlalchemy.sql.type_api import TypeEngine
 
 from ..custom_types import (
     _CUSTOM_DECIMAL,

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/src/snowflake/sqlalchemy/snowdialect.py

@@ -2,7 +2,6 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 #
 import operator
-import re
 from collections import defaultdict
 from enum import Enum
 from functools import reduce
@@ -16,7 +15,6 @@ from sqlalchemy import util as sa_util
 from sqlalchemy.engine import URL, default, reflection
 from sqlalchemy.schema import Table
 from sqlalchemy.sql import text
-from sqlalchemy.sql.elements import quoted_name
 from sqlalchemy.sql.sqltypes import NullType
 from sqlalchemy.types import FLOAT, Date, DateTime, Float, Time
 
@@ -24,6 +22,8 @@ from snowflake.connector import errors as sf_errors
 from snowflake.connector.connection import DEFAULT_CONFIGURATION
 from snowflake.connector.constants import UTF8
 from snowflake.sqlalchemy.compat import returns_unicode
+from snowflake.sqlalchemy.name_utils import _NameUtils
+from snowflake.sqlalchemy.structured_type_info_manager import _StructuredTypeInfoManager
 
 from ._constants import DIALECT_NAME
 from .base import (
@@ -42,7 +42,7 @@ from .custom_types import (
 )
 from .parser.custom_type_parser import *  # noqa
 from .parser.custom_type_parser import _CUSTOM_DECIMAL  # noqa
-from .parser.custom_type_parser import ischema_names, parse_index_columns, parse_type
+from .parser.custom_type_parser import ischema_names, parse_index_columns
 from .sql.custom_schema.custom_table_prefix import CustomTablePrefix
 from .util import (
     _update_connection_application_name,
@@ -157,6 +157,7 @@ class SnowflakeDialect(default.DefaultDialect):
         super().__init__(isolation_level=isolation_level, **kwargs)
         self.force_div_is_floordiv = force_div_is_floordiv
         self.div_is_floordiv = force_div_is_floordiv
+        self.name_utils = _NameUtils(self.identifier_preparer)
 
     def initialize(self, connection):
         super().initialize(connection)
@@ -282,29 +283,10 @@ class SnowflakeDialect(default.DefaultDialect):
             raise
 
     def normalize_name(self, name):
-        if name is None:
-            return None
-        if name == "":
-            return ""
-        if name.upper() == name and not self.identifier_preparer._requires_quotes(
-            name.lower()
-        ):
-            return name.lower()
-        elif name.lower() == name:
-            return quoted_name(name, quote=True)
-        else:
-            return name
+        return self.name_utils.normalize_name(name)
 
     def denormalize_name(self, name):
-        if name is None:
-            return None
-        if name == "":
-            return ""
-        elif name.lower() == name and not self.identifier_preparer._requires_quotes(
-            name.lower()
-        ):
-            name = name.upper()
-        return name
+        return self.name_utils.denormalize_name(name)
 
     def _denormalize_quote_join(self, *idents):
         ip = self.identifier_preparer
@@ -491,53 +473,31 @@ class SnowflakeDialect(default.DefaultDialect):
         )
         return foreign_key_map.get(table_name, [])
 
-    def table_columns_as_dict(self, columns):
-        result = {}
-        for column in columns:
-            result[column["name"]] = column
-        return result
-
     @reflection.cache
     def _get_schema_columns(self, connection, schema, **kw):
         """Get all columns in the schema, if we hit 'Information schema query returned too much data' problem return
         None, as it is cacheable and is an unexpected return type for this function"""
         ans = {}
-        current_database, _ = self._current_database_schema(connection, **kw)
+
+        schema_name = self.denormalize_name(schema)
+
+        result = self._query_all_columns_info(connection, schema_name, **kw)
+        if result is None:
+            return None
+
+        current_database, default_schema = self._current_database_schema(
+            connection, **kw
+        )
         full_schema_name = self._denormalize_quote_join(current_database, schema)
-        full_columns_descriptions = {}
-        try:
-            schema_primary_keys = self._get_schema_primary_keys(
-                connection, full_schema_name, **kw
-            )
-            schema_name = self.denormalize_name(schema)
 
-            result = connection.execute(
-                text(
-                    """
-            SELECT /* sqlalchemy:_get_schema_columns */
-                   ic.table_name,
-                   ic.column_name,
-                   ic.data_type,
-                   ic.character_maximum_length,
-                   ic.numeric_precision,
-                   ic.numeric_scale,
-                   ic.is_nullable,
-                   ic.column_default,
-                   ic.is_identity,
-                   ic.comment,
-                   ic.identity_start,
-                   ic.identity_increment
-              FROM information_schema.columns ic
-             WHERE ic.table_schema=:table_schema
-             ORDER BY ic.ordinal_position"""
-                ),
-                {"table_schema": schema_name},
-            )
-        except sa_exc.ProgrammingError as pe:
-            if pe.orig.errno == 90030:
-                # This means that there are too many tables in the schema, we need to go more granular
-                return None  # None triggers _get_table_columns while staying cacheable
-            raise
+        schema_primary_keys = self._get_schema_primary_keys(
+            connection, full_schema_name, **kw
+        )
+
+        structured_type_info_manager = _StructuredTypeInfoManager(
+            connection, self.name_utils, default_schema
+        )
+
         for (
             table_name,
             column_name,
@@ -572,25 +532,11 @@ class SnowflakeDialect(default.DefaultDialect):
                 elif issubclass(col_type, (sqltypes.String, sqltypes.BINARY)):
                     col_type_kw["length"] = character_maximum_length
                 elif issubclass(col_type, StructuredType):
-                    if (schema_name, table_name) not in full_columns_descriptions:
-                        full_columns_descriptions[(schema_name, table_name)] = (
-                            self.table_columns_as_dict(
-                                self._get_table_columns(
-                                    connection, table_name, schema_name
-                                )
-                            )
-                        )
-
-                    if (
-                        (schema_name, table_name) in full_columns_descriptions
-                        and column_name
-                        in full_columns_descriptions[(schema_name, table_name)]
-                    ):
-                        ans[table_name].append(
-                            full_columns_descriptions[(schema_name, table_name)][
-                                column_name
-                            ]
-                        )
+                    column_info = structured_type_info_manager.get_column_info(
+                        schema_name, table_name, column_name, **kw
+                    )
+                    if column_info:
+                        ans[table_name].append(column_info)
                         continue
                     else:
                         col_type = NullType
@@ -628,72 +574,6 @@ class SnowflakeDialect(default.DefaultDialect):
                 }
         return ans
 
-    @reflection.cache
-    def _get_table_columns(self, connection, table_name, schema=None, **kw):
-        """Get all columns in a table in a schema"""
-        ans = []
-        current_database, default_schema = self._current_database_schema(
-            connection, **kw
-        )
-        schema = schema if schema else default_schema
-        table_schema = self.denormalize_name(schema)
-        table_name = self.denormalize_name(table_name)
-        result = connection.execute(
-            text(
-                "DESC /* sqlalchemy:_get_schema_columns */"
-                f" TABLE {table_schema}.{table_name} TYPE = COLUMNS"
-            )
-        )
-        for desc_data in result:
-            column_name = desc_data[0]
-            coltype = desc_data[1]
-            is_nullable = desc_data[3]
-            column_default = desc_data[4]
-            primary_key = desc_data[5]
-            comment = desc_data[9]
-
-            column_name = self.normalize_name(column_name)
-            if column_name.startswith("sys_clustering_column"):
-                continue  # ignoring clustering column
-            type_instance = parse_type(coltype)
-            if isinstance(type_instance, NullType):
-                sa_util.warn(
-                    f"Did not recognize type '{coltype}' of column '{column_name}'"
-                )
-
-            identity = None
-            match = re.match(
-                r"IDENTITY START (?P<start>\d+) INCREMENT (?P<increment>\d+) (?P<order_type>ORDER|NOORDER)",
-                column_default if column_default else "",
-            )
-            if match:
-                identity = {
-                    "start": int(match.group("start")),
-                    "increment": int(match.group("increment")),
-                    "order_type": match.group("order_type"),
-                }
-            is_identity = identity is not None
-
-            ans.append(
-                {
-                    "name": column_name,
-                    "type": type_instance,
-                    "nullable": is_nullable == "Y",
-                    "default": None if is_identity else column_default,
-                    "autoincrement": is_identity,
-                    "comment": comment if comment != "" else None,
-                    "primary_key": primary_key == "Y",
-                }
-            )
-
-            if is_identity:
-                ans[-1]["identity"] = identity
-
-        # If we didn't find any columns for the table, the table doesn't exist.
-        if len(ans) == 0:
-            raise sa_exc.NoSuchTableError()
-        return ans
-
     def get_columns(self, connection, table_name, schema=None, **kw):
         """
         Gets all column info given the table info
@@ -704,8 +584,11 @@ class SnowflakeDialect(default.DefaultDialect):
 
         schema_columns = self._get_schema_columns(connection, schema, **kw)
         if schema_columns is None:
+            column_info_manager = _StructuredTypeInfoManager(
+                connection, self.name_utils, self.default_schema_name
+            )
             # Too many results, fall back to only query about single table
-            return self._get_table_columns(connection, table_name, schema, **kw)
+            return column_info_manager.get_table_columns(table_name, schema)
         normalized_table_name = self.normalize_name(table_name)
         if normalized_table_name not in schema_columns:
             raise sa_exc.NoSuchTableError()
@@ -719,6 +602,37 @@ class SnowflakeDialect(default.DefaultDialect):
                 prefixes_found.append(valid_prefix.name)
         return prefixes_found
 
+    @reflection.cache
+    def _query_all_columns_info(self, connection, schema_name, **kw):
+        try:
+            return connection.execute(
+                text(
+                    """
+            SELECT /* sqlalchemy:_get_schema_columns */
+                   ic.table_name,
+                   ic.column_name,
+                   ic.data_type,
+                   ic.character_maximum_length,
+                   ic.numeric_precision,
+                   ic.numeric_scale,
+                   ic.is_nullable,
+                   ic.column_default,
+                   ic.is_identity,
+                   ic.comment,
+                   ic.identity_start,
+                   ic.identity_increment
+              FROM information_schema.columns ic
+             WHERE ic.table_schema=:table_schema
+             ORDER BY ic.ordinal_position"""
+                ),
+                {"table_schema": schema_name},
+            )
+        except sa_exc.ProgrammingError as pe:
+            if pe.orig.errno == 90030:
+                # This means that there are too many tables in the schema, we need to go more granular
+                return None  # None triggers get_table_columns while staying cacheable
+            raise
+
     @reflection.cache
     def _get_schema_tables_info(self, connection, schema=None, **kw):
         """
@@ -955,9 +869,7 @@ class SnowflakeDialect(default.DefaultDialect):
             }
 
             if (schema, table_name) in indexes:
-                indexes[(schema, table_name)] = indexes[(schema, table_name)].append(
-                    index
-                )
+                indexes[(schema, table_name)].append(index)
             else:
                 indexes[(schema, table_name)] = [index]
 

snowflake_sqlalchemy-1.7.7/src/snowflake/sqlalchemy/structured_type_info_manager.py

@@ -0,0 +1,142 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+import re
+
+from sqlalchemy import util as sa_util
+from sqlalchemy.sql import text
+
+from snowflake.sqlalchemy.name_utils import _NameUtils
+from snowflake.sqlalchemy.parser.custom_type_parser import NullType, parse_type
+
+
+class _StructuredTypeInfoManager:
+    """
+    Manager for handling structured type information in Snowflake tables.
+    This class is responsible for retrieving, caching, and providing
+    column information for structured types in Snowflake tables. It maintains
+    a cache of column descriptions to avoid repeated database queries.
+    Attributes:
+        connection: The database connection to use for queries
+        full_columns_descriptions (dict): Cache of column descriptions by schema and table
+        name_utils (_NameUtils): Utility for normalizing and denormalizing names
+        default_schema (str): The default schema to use when none is specified
+    """
+
+    def __init__(self, connection, name_utils: _NameUtils, default_schema: str):
+        self.connection = connection
+        self.full_columns_descriptions = {}
+        self.name_utils = name_utils
+        self.default_schema = default_schema
+
+    def get_column_info(
+        self, schema_name: str, table_name: str, column_name: str, **kwargs
+    ):
+        self._load_structured_type_info(schema_name, table_name)
+        if (
+            (schema_name, table_name) in self.full_columns_descriptions
+            and column_name in self.full_columns_descriptions[(schema_name, table_name)]
+        ):
+            return self.full_columns_descriptions[(schema_name, table_name)][
+                column_name
+            ]
+        return None
+
+    def _load_structured_type_info(self, schema_name: str, table_name: str):
+        """Get column information for a structured type"""
+        if (schema_name, table_name) not in self.full_columns_descriptions:
+
+            column_definitions = self.get_table_columns(table_name, schema_name)
+            if not column_definitions:
+                self.full_columns_descriptions[(schema_name, table_name)] = {}
+                return False
+
+            self.full_columns_descriptions[(schema_name, table_name)] = (
+                self._table_columns_as_dict(column_definitions)
+            )
+        return True
+
+    def _table_columns_as_dict(self, columns: list):
+        result = {}
+        for column in columns:
+            result[column["name"]] = column
+        return result
+
+    def get_table_columns(self, table_name: str, schema: str = None):
+        """Get all columns in a table in a schema"""
+        ans = []
+
+        schema = schema if schema else self.default_schema
+
+        table_schema = self.name_utils.denormalize_name(schema)
+        table_name = self.name_utils.denormalize_name(table_name)
+        result = self._execute_desc(table_schema, table_name)
+        if not result:
+            return []
+
+        for desc_data in result:
+            column_name = desc_data[0]
+            coltype = desc_data[1]
+            is_nullable = desc_data[3]
+            column_default = desc_data[4]
+            primary_key = desc_data[5]
+            comment = desc_data[9]
+
+            column_name = self.name_utils.normalize_name(column_name)
+            if column_name.startswith("sys_clustering_column"):
+                continue  # ignoring clustering column
+            type_instance = parse_type(coltype)
+            if isinstance(type_instance, NullType):
+                sa_util.warn(
+                    f"Did not recognize type '{coltype}' of column '{column_name}'"
+                )
+
+            identity = None
+            match = re.match(
+                r"IDENTITY START (?P<start>\d+) INCREMENT (?P<increment>\d+) (?P<order_type>ORDER|NOORDER)",
+                column_default if column_default else "",
+            )
+            if match:
+                identity = {
+                    "start": int(match.group("start")),
+                    "increment": int(match.group("increment")),
+                    "order_type": match.group("order_type"),
+                }
+            is_identity = identity is not None
+
+            ans.append(
+                {
+                    "name": column_name,
+                    "type": type_instance,
+                    "nullable": is_nullable == "Y",
+                    "default": None if is_identity else column_default,
+                    "autoincrement": is_identity,
+                    "comment": comment if comment != "" else None,
+                    "primary_key": primary_key == "Y",
+                }
+            )
+
+            if is_identity:
+                ans[-1]["identity"] = identity
+
+        # If we didn't find any columns for the table, the table doesn't exist.
+        if len(ans) == 0:
+            return []
+        return ans
+
+    def _execute_desc(self, table_schema: str, table_name: str):
+        """Execute a DESC command handling a possible exception.
+        Exception can be caused by another session dropping the table while
+        once this process has started"""
+        try:
+            return self.connection.execute(
+                text(
+                    "DESC /* sqlalchemy:_get_schema_columns */"
+                    f" TABLE {table_schema}.{table_name} TYPE = COLUMNS"
+                )
+            )
+        except Exception:
+            sa_util.warn(
+                f"Failed to reflect '{table_schema}' .'{table_name}' table using sqlalchemy:_get_schema_columns"
+            )
+        return None

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/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.7.5"
+VERSION = "1.7.7"

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/tests/conftest.py

@@ -232,8 +232,11 @@ def assert_text_in_buf():
     def go(expected, occurrences=1):
         assert buf.buffer
         buflines = [rec.getMessage() for rec in buf.buffer]
+        ocurrences_found = 0
+        for line in buflines:
+            if line.find(expected) != -1:
+                ocurrences_found += 1
 
-        ocurrences_found = buflines.count(expected)
         assert occurrences == ocurrences_found, (
             f"Expected {occurrences} of {expected}, got {ocurrences_found} "
             f"occurrences in {buflines}."

{snowflake_sqlalchemy-1.7.5 → snowflake_sqlalchemy-1.7.7}/tests/sqlalchemy_test_suite/test_suite_20.py

@@ -3,11 +3,13 @@
 #
 import pytest
 from sqlalchemy import Integer, testing
+from sqlalchemy import types as sql_types
 from sqlalchemy.schema import Column, Sequence, Table
 from sqlalchemy.testing import config
 from sqlalchemy.testing.assertions import eq_
+from sqlalchemy.testing.suite import BizarroCharacterTest as _BizarroCharacterTest
 from sqlalchemy.testing.suite import (
-    BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
+    ComponentReflectionTestExtra as _ComponentReflectionTestExtra,
 )
 from sqlalchemy.testing.suite import (
     CompositeKeyReflectionTest as _CompositeKeyReflectionTest,
@@ -190,16 +192,74 @@ class CompositeKeyReflectionTest(_CompositeKeyReflectionTest):
         super().test_pk_column_order()
 
 
-class BizarroCharacterFKResolutionTest(_BizarroCharacterFKResolutionTest):
-    @testing.combinations(
-        ("id",), ("(3)",), ("col%p",), ("[brack]",), argnames="columnname"
-    )
+class BizarroCharacterTest(_BizarroCharacterTest):
+
+    def column_names_without_id():
+        return testing.combinations(
+            ("(3)",),
+            ("col%p",),
+            ("[brack]",),
+            argnames="columnname",
+        )
+
+    def column_names():
+        return testing.combinations(
+            ("id",),
+            ("(3)",),
+            ("col%p",),
+            ("[brack]",),
+            argnames="columnname",
+        )
+
+    def table_names():
+        return testing.combinations(
+            ("plain",),
+            ("(2)",),
+            ("[brackets]",),
+            argnames="tablename",
+        )
+
     @testing.variation("use_composite", [True, False])
-    @testing.combinations(
-        ("plain",),
-        ("(2)",),
-        ("[brackets]",),
-        argnames="tablename",
-    )
+    @column_names()
+    @table_names()
+    @testing.requires.foreign_key_constraint_reflection
     def test_fk_ref(self, connection, metadata, use_composite, tablename, columnname):
         super().test_fk_ref(connection, metadata, use_composite, tablename, columnname)
+
+    @column_names()
+    @table_names()
+    @testing.requires.identity_columns
+    def test_reflect_identity(self, tablename, columnname, connection, metadata):
+        super().test_reflect_identity(tablename, columnname, connection, metadata)
+
+    @column_names_without_id()
+    @table_names()
+    @testing.requires.comment_reflection
+    def test_reflect_comments(self, tablename, columnname, connection, metadata):
+        super().test_reflect_comments(tablename, columnname, connection, metadata)
+
+
+class ComponentReflectionTestExtra(_ComponentReflectionTestExtra):
+
+    @testing.requires.table_reflection
+    @testing.combinations(
+        sql_types.String,
+        sql_types.VARCHAR,
+        sql_types.CHAR,
+        (sql_types.NVARCHAR, testing.requires.nvarchar_types),
+        (sql_types.NCHAR, testing.requires.nvarchar_types),
+        argnames="type_",
+    )
+    def test_string_length_reflection(self, connection, metadata, type_):
+        typ = self._type_round_trip(connection, metadata, type_(52))[0]
+        if issubclass(type_, sql_types.VARCHAR):
+            assert isinstance(typ, sql_types.VARCHAR)
+        elif issubclass(
+            type_, sql_types.CHAR
+        ):  # char is not supported then mapped to VARCHAR
+            assert isinstance(typ, sql_types.VARCHAR)
+        else:
+            assert isinstance(typ, sql_types.String)
+
+        eq_(typ.length, 52)
+        assert isinstance(typ.length, int)