snowflake-sqlalchemy 1.7.2__tar.gz → 1.7.4__tar.gz

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/DESCRIPTION.md

@@ -6,8 +6,23 @@ Snowflake Documentation is available at:
 
 Source code is also available at:
 <https://github.com/snowflakedb/snowflake-sqlalchemy>
+# Unreleased Notes
 
 # Release Notes
+- v1.7.4(June 10, 2025)
+  - Fix dependency on DESCRIBE TABLE columns quantity (differences in columns caused by Snowflake parameters).
+  - Fix unnecessary condition was causing issues when parsing StructuredTypes columns.
+  - Update README.md to include instructions on how to verify package signatures using cosign.
+
+- v1.7.3(January 15, 2025)
+  - Fix support for SqlAlchemy ARRAY.
+  - Fix return value of snowflake get_table_names.
+  - Fix incorrect quoting of identifiers with `_` as initial character.
+  - Fix ARRAY type not supported in HYBRID tables.
+  - Add `force_div_is_floordiv` flag to override `div_is_floordiv` new default value `False` in `SnowflakeDialect`.
+    - With the flag in `False`, the `/` division operator will be treated as a float division and `//` as a floor division.
+    - This flag is added to maintain backward compatibility with the previous behavior of Snowflake Dialect division.
+    - This flag will be removed in the future and Snowflake Dialect will use `div_is_floor_div` as `False`.
 
 - v1.7.2(December 18, 2024)
   - Fix quoting of `_` as column name

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.7.2
+Version: 1.7.4
 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
@@ -63,7 +63,7 @@ Description-Content-Type: text/markdown
 Snowflake SQLAlchemy runs on the top of the Snowflake Connector for Python as a [dialect](http://docs.sqlalchemy.org/en/latest/dialects/) to bridge a Snowflake database and SQLAlchemy applications.
 
 
-| :exclamation:        | For production-affecting or urgent issues related to the connector, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). |
+| :exclamation: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
 |---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 
 
@@ -731,6 +731,28 @@ dynamic_test_table_1 = DynamicTable(
 - Direct data insertion into Dynamic Tables is not supported.
 
 
+## Verifying Package Signatures
+
+To ensure the authenticity and integrity of the Python package, follow the steps below to verify the package signature using `cosign`.
+
+**Steps to verify the signature:**
+- Install cosign:
+  - This example is using golang installation: [installing-cosign-with-go](https://edu.chainguard.dev/open-source/sigstore/cosign/how-to-install-cosign/#installing-cosign-with-go)
+- Download the file from the repository like pypi:
+  - https://pypi.org/project/snowflake-sqlalchemy/#files
+- Download the signature files from the release tag, replace the version number with the version you are verifying:
+  - https://github.com/snowflakedb/snowflake-sqlalchemy/releases/tag/v1.7.3
+- Verify signature:
+  ````bash
+  # replace the version number with the version you are verifying
+  ./cosign verify-blob snowflake_sqlalchemy-1.7.3-py3-none-any.whl  \
+  --certificate snowflake_sqlalchemy-1.7.3-py3-none-any.whl.crt \
+  --certificate-identity https://github.com/snowflakedb/snowflake-sqlalchemy/.github/workflows/python-publish.yml@refs/tags/v1.7.3 \
+  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+  --signature snowflake_sqlalchemy-1.7.3-py3-none-any.whl.sig
+  Verified OK
+  ````
+
 ## Support
 
 Feel free to file an issue or submit a PR here for general cases. For official support, contact Snowflake support at:

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/README.md

@@ -9,7 +9,7 @@
 Snowflake SQLAlchemy runs on the top of the Snowflake Connector for Python as a [dialect](http://docs.sqlalchemy.org/en/latest/dialects/) to bridge a Snowflake database and SQLAlchemy applications.
 
 
-| :exclamation:        | For production-affecting or urgent issues related to the connector, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). |
+| :exclamation: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
 |---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 
 
@@ -677,6 +677,28 @@ dynamic_test_table_1 = DynamicTable(
 - Direct data insertion into Dynamic Tables is not supported.
 
 
+## Verifying Package Signatures
+
+To ensure the authenticity and integrity of the Python package, follow the steps below to verify the package signature using `cosign`.
+
+**Steps to verify the signature:**
+- Install cosign:
+  - This example is using golang installation: [installing-cosign-with-go](https://edu.chainguard.dev/open-source/sigstore/cosign/how-to-install-cosign/#installing-cosign-with-go)
+- Download the file from the repository like pypi:
+  - https://pypi.org/project/snowflake-sqlalchemy/#files
+- Download the signature files from the release tag, replace the version number with the version you are verifying:
+  - https://github.com/snowflakedb/snowflake-sqlalchemy/releases/tag/v1.7.3
+- Verify signature:
+  ````bash
+  # replace the version number with the version you are verifying
+  ./cosign verify-blob snowflake_sqlalchemy-1.7.3-py3-none-any.whl  \
+  --certificate snowflake_sqlalchemy-1.7.3-py3-none-any.whl.crt \
+  --certificate-identity https://github.com/snowflakedb/snowflake-sqlalchemy/.github/workflows/python-publish.yml@refs/tags/v1.7.3 \
+  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+  --signature snowflake_sqlalchemy-1.7.3-py3-none-any.whl.sig
+  Verified OK
+  ````
+
 ## Support
 
 Feel free to file an issue or submit a PR here for general cases. For official support, contact Snowflake support at:

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/pyproject.toml

@@ -87,6 +87,11 @@ extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0"]
 features = ["development", "pandas"]
 python = "3.8"
 
+[tool.hatch.envs.sa14.scripts]
+test-dialect = "pytest --ignore_v20_test -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
+test-dialect-compatibility = "pytest --ignore_v20_test -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml tests/sqlalchemy_test_suite"
+test-dialect-aws = "pytest --ignore_v20_test -m \"aws\" -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
+
 [tool.hatch.envs.default.env-vars]
 COVERAGE_FILE = "coverage.xml"
 SQLACHEMY_WARN_20 = "1"
@@ -134,4 +139,5 @@ markers = [
   "requires_external_volume: tests that needs a external volume to be executed",
   "external: tests that could but should only run on our external CI",
   "feature_max_lob_size: tests that could but should only run on our external CI",
+  "feature_v20: tests that could but should only run on SqlAlchemy v20",
 ]

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/src/snowflake/sqlalchemy/base.py

@@ -6,6 +6,7 @@ import itertools
 import operator
 import re
 import string
+import warnings
 from typing import List
 
 from sqlalchemy import exc as sa_exc
@@ -116,7 +117,11 @@ AUTOCOMMIT_REGEXP = re.compile(
     r"\s*(?:UPDATE|INSERT|DELETE|MERGE|COPY)", re.I | re.UNICODE
 )
 # used for quoting identifiers ie. table names, column names, etc.
-ILLEGAL_INITIAL_CHARACTERS = frozenset({d for d in string.digits}.union({"_", "$"}))
+ILLEGAL_INITIAL_CHARACTERS = frozenset({d for d in string.digits}.union({"$"}))
+
+
+# used for quoting identifiers ie. table names, column names, etc.
+ILLEGAL_IDENTIFIERS = frozenset({d for d in string.digits}.union({"_"}))
 
 """
 Overwrite methods to handle Snowflake BCR change:
@@ -442,6 +447,7 @@ class SnowflakeORMSelectCompileState(context.ORMSelectCompileState):
 class SnowflakeIdentifierPreparer(compiler.IdentifierPreparer):
     reserved_words = {x.lower() for x in RESERVED_WORDS}
     illegal_initial_characters = ILLEGAL_INITIAL_CHARACTERS
+    illegal_identifiers = ILLEGAL_IDENTIFIERS
 
     def __init__(self, dialect, **kw):
         quote = '"'
@@ -470,6 +476,17 @@ class SnowflakeIdentifierPreparer(compiler.IdentifierPreparer):
 
         return self.quote_identifier(s) if n.quote else s
 
+    def _requires_quotes(self, value: str) -> bool:
+        """Return True if the given identifier requires quoting."""
+        lc_value = value.lower()
+        return (
+            lc_value in self.reserved_words
+            or lc_value in self.illegal_identifiers
+            or value[0] in self.illegal_initial_characters
+            or not self.legal_characters.match(str(value))
+            or (lc_value != value)
+        )
+
     def _split_schema_by_dot(self, schema):
         ret = []
         idx = 0
@@ -802,6 +819,26 @@ class SnowflakeCompiler(compiler.SQLCompiler):
             + join.onclause._compiler_dispatch(self, from_linter=from_linter, **kwargs)
         )
 
+    def visit_truediv_binary(self, binary, operator, **kw):
+        if self.dialect.div_is_floordiv:
+            warnings.warn(
+                "div_is_floordiv value will be changed to False in a future release. This will generate a behavior change on true and floor division. Please review https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#python-division-operator-performs-true-division-for-all-backends-added-floor-division",
+                PendingDeprecationWarning,
+                stacklevel=2,
+            )
+        return (
+            self.process(binary.left, **kw) + " / " + self.process(binary.right, **kw)
+        )
+
+    def visit_floordiv_binary(self, binary, operator, **kw):
+        if self.dialect.div_is_floordiv and IS_VERSION_20:
+            warnings.warn(
+                "div_is_floordiv value will be changed to False in a future release. This will generate a behavior change on true and floor division. Please review https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#python-division-operator-performs-true-division-for-all-backends-added-floor-division",
+                PendingDeprecationWarning,
+                stacklevel=2,
+            )
+        return super().visit_floordiv_binary(binary, operator, **kw)
+
     def render_literal_value(self, value, type_):
         # escape backslash
         return super().render_literal_value(value, type_).replace("\\", "\\\\")
@@ -1096,6 +1133,9 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
         )
 
     def visit_ARRAY(self, type_, **kw):
+        return "ARRAY"
+
+    def visit_SNOWFLAKE_ARRAY(self, type_, **kw):
         if type_.is_semi_structured:
             return "ARRAY"
         not_null = f" {NOT_NULL}" if type_.not_null else ""

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/src/snowflake/sqlalchemy/custom_types.py

@@ -83,7 +83,7 @@ class OBJECT(StructuredType):
 
 
 class ARRAY(StructuredType):
-    __visit_name__ = "ARRAY"
+    __visit_name__ = "SNOWFLAKE_ARRAY"
 
     def __init__(
         self,

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/src/snowflake/sqlalchemy/snowdialect.py

@@ -79,6 +79,9 @@ class SnowflakeDialect(default.DefaultDialect):
     colspecs = colspecs
     ischema_names = ischema_names
 
+    # target database treats the / division operator as “floor division”
+    div_is_floordiv = False
+
     # all str types must be converted in Unicode
     convert_unicode = True
 
@@ -147,10 +150,17 @@ class SnowflakeDialect(default.DefaultDialect):
 
     def __init__(
         self,
+        force_div_is_floordiv: bool = True,
         isolation_level: Optional[str] = SnowflakeIsolationLevel.READ_COMMITTED.value,
         **kwargs: Any,
     ):
         super().__init__(isolation_level=isolation_level, **kwargs)
+        self.force_div_is_floordiv = force_div_is_floordiv
+        self.div_is_floordiv = force_div_is_floordiv
+
+    def initialize(self, connection):
+        super().initialize(connection)
+        self.div_is_floordiv = self.force_div_is_floordiv
 
     @classmethod
     def dbapi(cls):
@@ -501,13 +511,6 @@ class SnowflakeDialect(default.DefaultDialect):
             )
             schema_name = self.denormalize_name(schema)
 
-            iceberg_table_names = self.get_table_names_with_prefix(
-                connection,
-                schema=schema_name,
-                prefix=CustomTablePrefix.ICEBERG.name,
-                info_cache=kw.get("info_cache", None),
-            )
-
             result = connection.execute(
                 text(
                     """
@@ -568,10 +571,7 @@ class SnowflakeDialect(default.DefaultDialect):
                     col_type_kw["scale"] = numeric_scale
                 elif issubclass(col_type, (sqltypes.String, sqltypes.BINARY)):
                     col_type_kw["length"] = character_maximum_length
-                elif (
-                    issubclass(col_type, StructuredType)
-                    and table_name in iceberg_table_names
-                ):
+                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(
@@ -644,21 +644,13 @@ class SnowflakeDialect(default.DefaultDialect):
                 f" TABLE {table_schema}.{table_name} TYPE = COLUMNS"
             )
         )
-        for (
-            column_name,
-            coltype,
-            _kind,
-            is_nullable,
-            column_default,
-            primary_key,
-            _unique_key,
-            _check,
-            _expression,
-            comment,
-            _policy_name,
-            _privacy_domain,
-            _name_mapping,
-        ) in result:
+        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"):
@@ -756,7 +748,7 @@ class SnowflakeDialect(default.DefaultDialect):
         ret = self._get_schema_tables_info(
             connection, schema, info_cache=kw.get("info_cache", None)
         ).keys()
-        return ret
+        return list(ret)
 
     @reflection.cache
     def get_view_names(self, connection, schema=None, **kw):

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/src/snowflake/sqlalchemy/sql/custom_schema/hybrid_table.py

@@ -32,6 +32,7 @@ class HybridTable(CustomTableBase):
 
     __table_prefixes__ = [CustomTablePrefix.HYBRID]
     _enforce_primary_keys: bool = True
+    _support_structured_types = True
 
     def __init__(
         self,

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/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.2"
+VERSION = "1.7.4"

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/__snapshots__/test_structured_datatypes.ambr

@@ -5,6 +5,9 @@
 # name: test_compile_table_with_double_map
   'CREATE TABLE clustered_user (\t"Id" INTEGER NOT NULL AUTOINCREMENT, \tname MAP(DECIMAL, MAP(DECIMAL, VARCHAR)), \tPRIMARY KEY ("Id"))'
 # ---
+# name: test_compile_table_with_sqlalchemy_array
+  'CREATE TABLE clustered_user (\t"Id" INTEGER NOT NULL AUTOINCREMENT, \tname ARRAY, \tPRIMARY KEY ("Id"))'
+# ---
 # name: test_compile_table_with_structured_data_type[structured_type0]
   'CREATE TABLE clustered_user (\t"Id" INTEGER NOT NULL AUTOINCREMENT, \tname MAP(DECIMAL(10, 0), MAP(DECIMAL(10, 0), VARCHAR(16777216))), \tPRIMARY KEY ("Id"))'
 # ---

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/conftest.py

@@ -47,6 +47,26 @@ snowflake.connector.connection.DEFAULT_CONFIGURATION[
 TEST_SCHEMA = f"sqlalchemy_tests_{str(uuid.uuid4()).replace('-', '_')}"
 
 
+def pytest_addoption(parser):
+    parser.addoption(
+        "--ignore_v20_test",
+        action="store_true",
+        default=False,
+        help="skip sqlalchemy 2.0 exclusive tests",
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--ignore_v20_test"):
+        # --ignore_v20_test given in cli: skip sqlalchemy 2.0 tests
+        skip_feature_v2 = pytest.mark.skip(
+            reason="need remove --ignore_v20_test option to run"
+        )
+        for item in items:
+            if "feature_v20" in item.keywords:
+                item.add_marker(skip_feature_v2)
+
+
 @pytest.fixture(scope="session")
 def on_travis():
     return os.getenv("TRAVIS", "").lower() == "true"
@@ -183,6 +203,12 @@ def get_engine(url: URL, **engine_kwargs):
         "echo": True,
     }
     engine_params.update(engine_kwargs)
+
+    connect_args = engine_params.get("connect_args", {}).copy()
+    connect_args["disable_ocsp_checks"] = True
+    connect_args["insecure_mode"] = True
+    engine_params["connect_args"] = connect_args
+
     engine = create_engine(url, **engine_params)
     return engine
 

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/custom_tables/__snapshots__/test_compile_hybrid_table.ambr

@@ -5,3 +5,6 @@
 # name: test_compile_hybrid_table_orm
   'CREATE HYBRID TABLE test_hybrid_table_orm (\tid INTEGER NOT NULL AUTOINCREMENT, \tname VARCHAR, \tPRIMARY KEY (id))'
 # ---
+# name: test_compile_hybrid_table_with_array
+  'CREATE HYBRID TABLE test_hybrid_table (\tid INTEGER NOT NULL AUTOINCREMENT, \tname VARCHAR, \tgeom GEOMETRY, \tarray ARRAY, \tPRIMARY KEY (id))'
+# ---

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/custom_tables/__snapshots__/test_reflect_snowflake_table.ambr

@@ -21,6 +21,9 @@
     }),
   ])
 # ---
+# name: test_reflection_of_table_with_object_data_type
+  'CREATE TABLE test_snowflake_table_reflection (\tid DECIMAL(38, 0) NOT NULL, \tname OBJECT, \tCONSTRAINT demo_name PRIMARY KEY (id))'
+# ---
 # name: test_simple_reflection_of_table_as_snowflake_table
   'CREATE TABLE test_snowflake_table_reflection (\tid DECIMAL(38, 0) NOT NULL, \tname VARCHAR(16777216), \tCONSTRAINT demo_name PRIMARY KEY (id))'
 # ---

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/custom_tables/test_compile_hybrid_table.py

@@ -1,15 +1,14 @@
 #
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 #
-import pytest
+
 from sqlalchemy import Column, Integer, MetaData, String
 from sqlalchemy.orm import declarative_base
 from sqlalchemy.sql.ddl import CreateTable
 
-from snowflake.sqlalchemy import GEOMETRY, HybridTable
+from snowflake.sqlalchemy import ARRAY, GEOMETRY, HybridTable
 
 
-@pytest.mark.aws
 def test_compile_hybrid_table(sql_compiler, snapshot):
     metadata = MetaData()
     table_name = "test_hybrid_table"
@@ -28,7 +27,25 @@ def test_compile_hybrid_table(sql_compiler, snapshot):
     assert actual == snapshot
 
 
-@pytest.mark.aws
+def test_compile_hybrid_table_with_array(sql_compiler, snapshot):
+    metadata = MetaData()
+    table_name = "test_hybrid_table"
+    test_geometry = HybridTable(
+        table_name,
+        metadata,
+        Column("id", Integer, primary_key=True),
+        Column("name", String),
+        Column("geom", GEOMETRY),
+        Column("array", ARRAY),
+    )
+
+    value = CreateTable(test_geometry)
+
+    actual = sql_compiler(value)
+
+    assert actual == snapshot
+
+
 def test_compile_hybrid_table_orm(sql_compiler, snapshot):
     Base = declarative_base()
 

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/custom_tables/test_create_iceberg_table.py

@@ -9,7 +9,7 @@ from snowflake.sqlalchemy import IcebergTable
 
 
 @pytest.mark.aws
-def test_create_iceberg_table(engine_testaccount, snapshot):
+def test_create_iceberg_table(engine_testaccount):
     metadata = MetaData()
     external_volume_name = "exvol"
     create_external_volume = f"""
@@ -19,7 +19,7 @@ def test_create_iceberg_table(engine_testaccount, snapshot):
             (
                 NAME = 'my-s3-us-west-2'
                 STORAGE_PROVIDER = 'S3'
-                STORAGE_BASE_URL = 's3://MY_EXAMPLE_BUCKET/'
+                STORAGE_BASE_URL = 's3://myexamplebucket/'
                 STORAGE_AWS_ROLE_ARN = 'arn:aws:iam::123456789012:role/myrole'
                 ENCRYPTION=(TYPE='AWS_SSE_KMS' KMS_KEY_ID='1234abcd-12ab-34cd-56ef-1234567890ab')
             )
@@ -40,4 +40,7 @@ def test_create_iceberg_table(engine_testaccount, snapshot):
         metadata.create_all(engine_testaccount)
 
     error_str = str(argument_error.value)
-    assert error_str[: error_str.rfind("\n")] == snapshot
+    assert (
+        "(snowflake.connector.errors.ProgrammingError)"
+        in error_str[: error_str.rfind("\n")]
+    )

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/custom_tables/test_reflect_snowflake_table.py

@@ -7,6 +7,36 @@ from sqlalchemy.sql.ddl import CreateTable
 from snowflake.sqlalchemy import SnowflakeTable
 
 
+def test_reflection_of_table_with_object_data_type(
+    engine_testaccount, db_parameters, sql_compiler, snapshot
+):
+    metadata = MetaData()
+    table_name = "test_snowflake_table_reflection"
+
+    create_table_sql = f"""
+   CREATE TABLE {table_name} (id INT primary key, name OBJECT);
+    """
+
+    with engine_testaccount.connect() as connection:
+        connection.exec_driver_sql(create_table_sql)
+
+    snowflake_test_table = Table(table_name, metadata, autoload_with=engine_testaccount)
+    constraint = snowflake_test_table.constraints.pop()
+    constraint.name = "demo_name"
+    snowflake_test_table.constraints.add(constraint)
+
+    try:
+        with engine_testaccount.connect():
+            value = CreateTable(snowflake_test_table)
+
+            actual = sql_compiler(value)
+
+            assert actual == snapshot
+
+    finally:
+        metadata.drop_all(engine_testaccount)
+
+
 def test_simple_reflection_of_table_as_sqlalchemy_table(
     engine_testaccount, db_parameters, sql_compiler, snapshot
 ):

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/test_compiler.py

@@ -2,12 +2,14 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 #
 
+import pytest
 from sqlalchemy import Integer, String, and_, func, insert, select
 from sqlalchemy.schema import DropColumnComment, DropTableComment
 from sqlalchemy.sql import column, quoted_name, table
 from sqlalchemy.testing.assertions import AssertsCompiledSQL
 
 from snowflake.sqlalchemy import snowdialect
+from src.snowflake.sqlalchemy.snowdialect import SnowflakeDialect
 
 table1 = table(
     "table1", column("id", Integer), column("name", String), column("value", Integer)
@@ -48,6 +50,21 @@ class TestSnowflakeCompiler(AssertsCompiledSQL):
             dialect="snowflake",
         )
 
+    def test_underscore_as_initial_character_as_non_quoted_identifier(self):
+        _table = table(
+            "table_1745924",
+            column("ca", Integer),
+            column("cb", String),
+            column("_identifier", String),
+        )
+
+        stmt = insert(_table).values(ca=1, cb="test", _identifier="test_")
+        self.assert_compile(
+            stmt,
+            "INSERT INTO table_1745924 (ca, cb, _identifier) VALUES (%(ca)s, %(cb)s, %(_identifier)s)",
+            dialect="snowflake",
+        )
+
     def test_multi_table_delete(self):
         statement = table1.delete().where(table1.c.id == table2.c.id)
         self.assert_compile(
@@ -135,3 +152,80 @@ def test_outer_lateral_join():
         str(stmt.compile(dialect=snowdialect.dialect()))
         == "SELECT colname AS label \nFROM abc JOIN LATERAL flatten(PARSE_JSON(colname2)) AS anon_1 GROUP BY colname"
     )
+
+
+@pytest.mark.feature_v20
+def test_division_operator_with_force_div_is_floordiv_false():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 / col2
+    assert (
+        str(stmt.compile(dialect=SnowflakeDialect(force_div_is_floordiv=False)))
+        == "col1 / col2"
+    )
+
+
+@pytest.mark.feature_v20
+def test_division_operator_with_denominator_expr_force_div_is_floordiv_false():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 / func.sqrt(col2)
+    assert (
+        str(stmt.compile(dialect=SnowflakeDialect(force_div_is_floordiv=False)))
+        == "col1 / sqrt(col2)"
+    )
+
+
+@pytest.mark.feature_v20
+def test_division_operator_with_force_div_is_floordiv_default_true():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 / col2
+    assert str(stmt.compile(dialect=SnowflakeDialect())) == "col1 / col2"
+
+
+@pytest.mark.feature_v20
+def test_division_operator_with_denominator_expr_force_div_is_floordiv_default_true():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 / func.sqrt(col2)
+    assert str(stmt.compile(dialect=SnowflakeDialect())) == "col1 / sqrt(col2)"
+
+
+@pytest.mark.feature_v20
+def test_floor_division_operator_force_div_is_floordiv_false():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 // col2
+    assert (
+        str(stmt.compile(dialect=SnowflakeDialect(force_div_is_floordiv=False)))
+        == "FLOOR(col1 / col2)"
+    )
+
+
+@pytest.mark.feature_v20
+def test_floor_division_operator_with_denominator_expr_force_div_is_floordiv_false():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 // func.sqrt(col2)
+    assert (
+        str(stmt.compile(dialect=SnowflakeDialect(force_div_is_floordiv=False)))
+        == "FLOOR(col1 / sqrt(col2))"
+    )
+
+
+@pytest.mark.feature_v20
+def test_floor_division_operator_force_div_is_floordiv_default_true():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 // col2
+    assert str(stmt.compile(dialect=SnowflakeDialect())) == "col1 / col2"
+
+
+@pytest.mark.feature_v20
+def test_floor_division_operator_with_denominator_expr_force_div_is_floordiv_default_true():
+    col1 = column("col1", Integer)
+    col2 = column("col2", Integer)
+    stmt = col1 // func.sqrt(col2)
+    res = stmt.compile(dialect=SnowflakeDialect())
+    assert str(res) == "FLOOR(col1 / sqrt(col2))"

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/test_core.py

@@ -31,13 +31,15 @@ from sqlalchemy import (
     create_engine,
     dialects,
     exc,
+    func,
     insert,
     inspect,
     text,
 )
 from sqlalchemy.exc import DBAPIError, NoSuchTableError, OperationalError
-from sqlalchemy.sql import and_, not_, or_, select
+from sqlalchemy.sql import and_, literal, not_, or_, select
 from sqlalchemy.sql.ddl import CreateTable
+from sqlalchemy.testing.assertions import eq_
 
 import snowflake.connector.errors
 import snowflake.sqlalchemy.snowdialect
@@ -469,6 +471,7 @@ def test_inspect_column(engine_testaccount):
     try:
         inspector = inspect(engine_testaccount)
         all_table_names = inspector.get_table_names()
+        assert isinstance(all_table_names, list)
         assert "users" in all_table_names
         assert "addresses" in all_table_names
 
@@ -1863,3 +1866,86 @@ def test_snowflake_sqlalchemy_as_valid_client_type():
         snowflake.connector.connection.DEFAULT_CONFIGURATION[
             "internal_application_version"
         ] = origin_internal_app_version
+
+
+@pytest.mark.parametrize(
+    "operation",
+    [
+        [
+            literal(5),
+            literal(10),
+            0.5,
+        ],
+        [literal(5), func.sqrt(literal(10)), 1.5811388300841895],
+        [literal(4), literal(5), decimal.Decimal("0.800000")],
+        [literal(2), literal(2), 1.0],
+        [literal(3), literal(2), 1.5],
+        [literal(4), literal(1.5), 2.666667],
+        [literal(5.5), literal(10.7), 0.5140187],
+        [literal(5.5), literal(8), 0.6875],
+    ],
+)
+def test_true_division_operation(engine_testaccount, operation):
+    # expected_warning = "div_is_floordiv value will be changed to False in a future release. This will generate a behavior change on true and floor division. Please review https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#python-division-operator-performs-true-division-for-all-backends-added-floor-division"
+    # with pytest.warns(PendingDeprecationWarning, match=expected_warning):
+    with engine_testaccount.connect() as conn:
+        eq_(
+            conn.execute(select(operation[0] / operation[1])).fetchall(),
+            [((operation[2]),)],
+        )
+
+
+@pytest.mark.parametrize(
+    "operation",
+    [
+        [literal(5), literal(10), 0.5, 0.5],
+        [literal(5), func.sqrt(literal(10)), 1.5811388300841895, 1.0],
+        [
+            literal(4),
+            literal(5),
+            decimal.Decimal("0.800000"),
+            decimal.Decimal("0.800000"),
+        ],
+        [literal(2), literal(2), 1.0, 1.0],
+        [literal(3), literal(2), 1.5, 1.5],
+        [literal(4), literal(1.5), 2.666667, 2.0],
+        [literal(5.5), literal(10.7), 0.5140187, 0],
+        [literal(5.5), literal(8), 0.6875, 0.6875],
+    ],
+)
+@pytest.mark.feature_v20
+def test_division_force_div_is_floordiv_default(engine_testaccount, operation):
+    expected_warning = "div_is_floordiv value will be changed to False in a future release. This will generate a behavior change on true and floor division. Please review https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#python-division-operator-performs-true-division-for-all-backends-added-floor-division"
+    with pytest.warns(PendingDeprecationWarning, match=expected_warning):
+        with engine_testaccount.connect() as conn:
+            eq_(
+                conn.execute(
+                    select(operation[0] / operation[1], operation[0] // operation[1])
+                ).fetchall(),
+                [(operation[2], operation[3])],
+            )
+
+
+@pytest.mark.parametrize(
+    "operation",
+    [
+        [literal(5), literal(10), 0.5, 0],
+        [literal(5), func.sqrt(literal(10)), 1.5811388300841895, 1.0],
+        [literal(4), literal(5), decimal.Decimal("0.800000"), 0],
+        [literal(2), literal(2), 1.0, 1.0],
+        [literal(3), literal(2), 1.5, 1],
+        [literal(4), literal(1.5), 2.666667, 2.0],
+        [literal(5.5), literal(10.7), 0.5140187, 0],
+        [literal(5.5), literal(8), 0.6875, 0],
+    ],
+)
+@pytest.mark.feature_v20
+def test_division_force_div_is_floordiv_false(db_parameters, operation):
+    engine = create_engine(URL(**db_parameters), **{"force_div_is_floordiv": False})
+    with engine.connect() as conn:
+        eq_(
+            conn.execute(
+                select(operation[0] / operation[1], operation[0] // operation[1])
+            ).fetchall(),
+            [(operation[2], operation[3])],
+        )

{snowflake_sqlalchemy-1.7.2 → snowflake_sqlalchemy-1.7.4}/tests/test_structured_datatypes.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 #
 import pytest
+import sqlalchemy as sa
 from sqlalchemy import (
     Column,
     Integer,
@@ -47,6 +48,20 @@ def test_compile_table_with_structured_data_type(
     assert sql_compiler(create_table) == snapshot
 
 
+def test_compile_table_with_sqlalchemy_array(sql_compiler, snapshot):
+    metadata = MetaData()
+    user_table = Table(
+        "clustered_user",
+        metadata,
+        Column("Id", Integer, primary_key=True),
+        Column("name", sa.ARRAY(sa.String)),
+    )
+
+    create_table = CreateTable(user_table)
+
+    assert sql_compiler(create_table) == snapshot
+
+
 @pytest.mark.requires_external_volume
 def test_insert_map(engine_testaccount, external_volume, base_location, snapshot):
     metadata = MetaData()