snowflake-sqlalchemy 1.7.0__tar.gz → 1.7.1__tar.gz

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/DESCRIPTION.md

@@ -9,7 +9,11 @@ Source code is also available at:
 
 # Release Notes
 
-- v1.7.0(November 22, 2024)
+- v1.7.1(December 02, 2024)
+  - Add support for partition by to copy into <location>
+  - Fix BOOLEAN type not found in snowdialect
+
+- v1.7.0(November 21, 2024)
 
   - Add support for dynamic tables and required options
   - Add support for hybrid tables

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-sqlalchemy
-Version: 1.7.0
+Version: 1.7.1
 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
@@ -60,6 +60,11 @@ 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). |
+|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+
 ## Prerequisites
 
 ### Snowflake Connector for Python
@@ -256,7 +261,7 @@ finally:
 
 # Best
 try:
-    with engine.connext() as connection:
+    with engine.connect() as connection:
         connection.execute(text(<SQL>))
         # or
         connection.exec_driver_sql(<SQL>)
@@ -277,11 +282,43 @@ t = Table('mytable', metadata,
 
 ### Object Name Case Handling
 
-Snowflake stores all case-insensitive object names in uppercase text. In contrast, SQLAlchemy considers all lowercase object names to be case-insensitive. Snowflake SQLAlchemy converts the object name case during schema-level communication, i.e. during table and index reflection. If you use uppercase object names, SQLAlchemy assumes they are case-sensitive and encloses the names with quotes. This behavior will cause mismatches agaisnt data dictionary data received from Snowflake, so unless identifier names have been truly created as case sensitive using quotes, e.g., `"TestDb"`, all lowercase names should be used on the SQLAlchemy side.
+Snowflake stores all case-insensitive object names in uppercase text. In contrast, SQLAlchemy considers all lowercase object names to be case-insensitive. Snowflake SQLAlchemy converts the object name case during schema-level communication, i.e. during table and index reflection. If you use uppercase object names, SQLAlchemy assumes they are case-sensitive and encloses the names with quotes. This behavior will cause mismatches against data dictionary data received from Snowflake, so unless identifier names have been truly created as case sensitive using quotes, e.g., `"TestDb"`, all lowercase names should be used on the SQLAlchemy side.
 
 ### Index Support
 
-Snowflake does not utilize indexes, so neither does Snowflake SQLAlchemy.
+Indexes are supported only for Hybrid Tables in Snowflake SQLAlchemy. For more details on limitations and use cases, refer to the [Create Index documentation](https://docs.snowflake.com/en/sql-reference/constraints-indexes.html). You can create an index using the following methods:
+
+#### Single Column Index
+
+You can create a single column index by setting the `index=True` parameter on the column or by explicitly defining an `Index` object.
+
+```python
+hybrid_test_table_1 = HybridTable(
+  "table_name",
+  metadata,
+  Column("column1", Integer, primary_key=True),
+  Column("column2", String, index=True),
+  Index("index_1", "column1", "column2")
+)
+
+metadata.create_all(engine_testaccount)
+```
+
+#### Multi-Column Index
+
+For multi-column indexes, you define the `Index` object specifying the columns that should be indexed.
+
+```python
+hybrid_test_table_1 = HybridTable(
+  "table_name",
+  metadata,
+  Column("column1", Integer, primary_key=True),
+  Column("column2", String),
+  Index("index_1", "column1", "column2")
+)
+
+metadata.create_all(engine_testaccount)
+```
 
 ### Numpy Data Type Support
 
@@ -508,6 +545,117 @@ copy_into = CopyIntoStorage(from_=users,
 connection.execute(copy_into)
 ```
 
+### Iceberg Table with Snowflake Catalog support
+
+Snowflake SQLAlchemy supports Iceberg Tables with the Snowflake Catalog, along with various related parameters. For detailed information about Iceberg Tables, refer to the Snowflake [CREATE ICEBERG](https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table-snowflake) documentation.
+
+To create an Iceberg Table using Snowflake SQLAlchemy, you can define the table using the SQLAlchemy Core syntax as follows:
+
+```python
+table = IcebergTable(
+    "myuser",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String),
+    external_volume=external_volume_name,
+    base_location="my_iceberg_table",
+    as_query="SELECT * FROM table"
+)
+```
+
+Alternatively, you can define the table using a declarative approach:
+
+```python
+class MyUser(Base):
+    __tablename__ = "myuser"
+
+    @classmethod
+    def __table_cls__(cls, name, metadata, *arg, **kw):
+        return IcebergTable(name, metadata, *arg, **kw)
+
+    __table_args__ = {
+        "external_volume": "my_external_volume",
+        "base_location": "my_iceberg_table",
+        "as_query": "SELECT * FROM table",
+    }
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+```
+
+### Hybrid Table support
+
+Snowflake SQLAlchemy supports Hybrid Tables with indexes. For detailed information, refer to the Snowflake [CREATE HYBRID TABLE](https://docs.snowflake.com/en/sql-reference/sql/create-hybrid-table) documentation.
+
+To create a Hybrid Table and add an index, you can use the SQLAlchemy Core syntax as follows:
+
+```python
+table = HybridTable(
+    "myuser",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String),
+    Index("idx_name", "name")
+)
+```
+
+Alternatively, you can define the table using the declarative approach:
+
+```python
+class MyUser(Base):
+    __tablename__ = "myuser"
+
+    @classmethod
+    def __table_cls__(cls, name, metadata, *arg, **kw):
+        return HybridTable(name, metadata, *arg, **kw)
+
+    __table_args__ = (
+        Index("idx_name", "name"),
+    )
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+```
+
+### Dynamic Tables support
+
+Snowflake SQLAlchemy supports Dynamic Tables. For detailed information, refer to the Snowflake [CREATE DYNAMIC TABLE](https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table) documentation.
+
+To create a Dynamic Table, you can use the SQLAlchemy Core syntax as follows:
+
+```python
+dynamic_test_table_1 = DynamicTable(
+    "dynamic_MyUser",
+    metadata,
+    Column("id", Integer),
+    Column("name", String),
+    target_lag=(1, TimeUnit.HOURS),  # Additionally, you can use SnowflakeKeyword.DOWNSTREAM
+    warehouse='test_wh',
+    refresh_mode=SnowflakeKeyword.FULL,
+    as_query="SELECT id, name from MyUser;"
+)
+```
+
+Alternatively, you can define a table without columns using the SQLAlchemy `select()` construct:
+
+```python
+dynamic_test_table_1 = DynamicTable(
+    "dynamic_MyUser",
+    metadata,
+    target_lag=(1, TimeUnit.HOURS),
+    warehouse='test_wh',
+    refresh_mode=SnowflakeKeyword.FULL,
+    as_query=select(MyUser.id, MyUser.name)
+)
+```
+
+### Notes
+
+- Defining a primary key in a Dynamic Table is not supported, meaning declarative tables don’t support Dynamic Tables.
+- When using the `as_query` parameter with a string, you must explicitly define the columns. However, if you use the SQLAlchemy `select()` construct, you don’t need to explicitly define the columns.
+- Direct data insertion into Dynamic Tables is not supported.
+
+
 ## 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.0 → snowflake_sqlalchemy-1.7.1}/README.md

@@ -8,6 +8,11 @@
 
 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). |
+|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+
 ## Prerequisites
 
 ### Snowflake Connector for Python
@@ -204,7 +209,7 @@ finally:
 
 # Best
 try:
-    with engine.connext() as connection:
+    with engine.connect() as connection:
         connection.execute(text(<SQL>))
         # or
         connection.exec_driver_sql(<SQL>)
@@ -225,11 +230,43 @@ t = Table('mytable', metadata,
 
 ### Object Name Case Handling
 
-Snowflake stores all case-insensitive object names in uppercase text. In contrast, SQLAlchemy considers all lowercase object names to be case-insensitive. Snowflake SQLAlchemy converts the object name case during schema-level communication, i.e. during table and index reflection. If you use uppercase object names, SQLAlchemy assumes they are case-sensitive and encloses the names with quotes. This behavior will cause mismatches agaisnt data dictionary data received from Snowflake, so unless identifier names have been truly created as case sensitive using quotes, e.g., `"TestDb"`, all lowercase names should be used on the SQLAlchemy side.
+Snowflake stores all case-insensitive object names in uppercase text. In contrast, SQLAlchemy considers all lowercase object names to be case-insensitive. Snowflake SQLAlchemy converts the object name case during schema-level communication, i.e. during table and index reflection. If you use uppercase object names, SQLAlchemy assumes they are case-sensitive and encloses the names with quotes. This behavior will cause mismatches against data dictionary data received from Snowflake, so unless identifier names have been truly created as case sensitive using quotes, e.g., `"TestDb"`, all lowercase names should be used on the SQLAlchemy side.
 
 ### Index Support
 
-Snowflake does not utilize indexes, so neither does Snowflake SQLAlchemy.
+Indexes are supported only for Hybrid Tables in Snowflake SQLAlchemy. For more details on limitations and use cases, refer to the [Create Index documentation](https://docs.snowflake.com/en/sql-reference/constraints-indexes.html). You can create an index using the following methods:
+
+#### Single Column Index
+
+You can create a single column index by setting the `index=True` parameter on the column or by explicitly defining an `Index` object.
+
+```python
+hybrid_test_table_1 = HybridTable(
+  "table_name",
+  metadata,
+  Column("column1", Integer, primary_key=True),
+  Column("column2", String, index=True),
+  Index("index_1", "column1", "column2")
+)
+
+metadata.create_all(engine_testaccount)
+```
+
+#### Multi-Column Index
+
+For multi-column indexes, you define the `Index` object specifying the columns that should be indexed.
+
+```python
+hybrid_test_table_1 = HybridTable(
+  "table_name",
+  metadata,
+  Column("column1", Integer, primary_key=True),
+  Column("column2", String),
+  Index("index_1", "column1", "column2")
+)
+
+metadata.create_all(engine_testaccount)
+```
 
 ### Numpy Data Type Support
 
@@ -456,6 +493,117 @@ copy_into = CopyIntoStorage(from_=users,
 connection.execute(copy_into)
 ```
 
+### Iceberg Table with Snowflake Catalog support
+
+Snowflake SQLAlchemy supports Iceberg Tables with the Snowflake Catalog, along with various related parameters. For detailed information about Iceberg Tables, refer to the Snowflake [CREATE ICEBERG](https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table-snowflake) documentation.
+
+To create an Iceberg Table using Snowflake SQLAlchemy, you can define the table using the SQLAlchemy Core syntax as follows:
+
+```python
+table = IcebergTable(
+    "myuser",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String),
+    external_volume=external_volume_name,
+    base_location="my_iceberg_table",
+    as_query="SELECT * FROM table"
+)
+```
+
+Alternatively, you can define the table using a declarative approach:
+
+```python
+class MyUser(Base):
+    __tablename__ = "myuser"
+
+    @classmethod
+    def __table_cls__(cls, name, metadata, *arg, **kw):
+        return IcebergTable(name, metadata, *arg, **kw)
+
+    __table_args__ = {
+        "external_volume": "my_external_volume",
+        "base_location": "my_iceberg_table",
+        "as_query": "SELECT * FROM table",
+    }
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+```
+
+### Hybrid Table support
+
+Snowflake SQLAlchemy supports Hybrid Tables with indexes. For detailed information, refer to the Snowflake [CREATE HYBRID TABLE](https://docs.snowflake.com/en/sql-reference/sql/create-hybrid-table) documentation.
+
+To create a Hybrid Table and add an index, you can use the SQLAlchemy Core syntax as follows:
+
+```python
+table = HybridTable(
+    "myuser",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String),
+    Index("idx_name", "name")
+)
+```
+
+Alternatively, you can define the table using the declarative approach:
+
+```python
+class MyUser(Base):
+    __tablename__ = "myuser"
+
+    @classmethod
+    def __table_cls__(cls, name, metadata, *arg, **kw):
+        return HybridTable(name, metadata, *arg, **kw)
+
+    __table_args__ = (
+        Index("idx_name", "name"),
+    )
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+```
+
+### Dynamic Tables support
+
+Snowflake SQLAlchemy supports Dynamic Tables. For detailed information, refer to the Snowflake [CREATE DYNAMIC TABLE](https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table) documentation.
+
+To create a Dynamic Table, you can use the SQLAlchemy Core syntax as follows:
+
+```python
+dynamic_test_table_1 = DynamicTable(
+    "dynamic_MyUser",
+    metadata,
+    Column("id", Integer),
+    Column("name", String),
+    target_lag=(1, TimeUnit.HOURS),  # Additionally, you can use SnowflakeKeyword.DOWNSTREAM
+    warehouse='test_wh',
+    refresh_mode=SnowflakeKeyword.FULL,
+    as_query="SELECT id, name from MyUser;"
+)
+```
+
+Alternatively, you can define a table without columns using the SQLAlchemy `select()` construct:
+
+```python
+dynamic_test_table_1 = DynamicTable(
+    "dynamic_MyUser",
+    metadata,
+    target_lag=(1, TimeUnit.HOURS),
+    warehouse='test_wh',
+    refresh_mode=SnowflakeKeyword.FULL,
+    as_query=select(MyUser.id, MyUser.name)
+)
+```
+
+### Notes
+
+- Defining a primary key in a Dynamic Table is not supported, meaning declarative tables don’t support Dynamic Tables.
+- When using the `as_query` parameter with a string, you must explicitly define the columns. However, if you use the SQLAlchemy `select()` construct, you don’t need to explicitly define the columns.
+- Direct data insertion into Dynamic Tables is not supported.
+
+
 ## 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.0 → snowflake_sqlalchemy-1.7.1}/src/snowflake/sqlalchemy/base.py

@@ -16,7 +16,8 @@ from sqlalchemy.orm.context import _MapperEntity
 from sqlalchemy.schema import Sequence, Table
 from sqlalchemy.sql import compiler, expression, functions
 from sqlalchemy.sql.base import CompileState
-from sqlalchemy.sql.elements import quoted_name
+from sqlalchemy.sql.elements import BindParameter, quoted_name
+from sqlalchemy.sql.expression import Executable
 from sqlalchemy.sql.selectable import Lateral, SelectState
 
 from snowflake.sqlalchemy._constants import DIALECT_NAME
@@ -563,9 +564,8 @@ class SnowflakeCompiler(compiler.SQLCompiler):
             if isinstance(copy_into.into, Table)
             else copy_into.into._compiler_dispatch(self, **kw)
         )
-        from_ = None
         if isinstance(copy_into.from_, Table):
-            from_ = copy_into.from_
+            from_ = copy_into.from_.name
         # this is intended to catch AWSBucket and AzureContainer
         elif (
             isinstance(copy_into.from_, AWSBucket)
@@ -576,6 +576,21 @@ class SnowflakeCompiler(compiler.SQLCompiler):
         # everything else (selects, etc.)
         else:
             from_ = f"({copy_into.from_._compiler_dispatch(self, **kw)})"
+
+        partition_by_value = None
+        if isinstance(copy_into.partition_by, (BindParameter, Executable)):
+            partition_by_value = copy_into.partition_by.compile(
+                compile_kwargs={"literal_binds": True}
+            )
+        elif copy_into.partition_by is not None:
+            partition_by_value = copy_into.partition_by
+
+        partition_by = (
+            f"PARTITION BY {partition_by_value}"
+            if partition_by_value is not None and partition_by_value != ""
+            else ""
+        )
+
         credentials, encryption = "", ""
         if isinstance(into, tuple):
             into, credentials, encryption = into
@@ -586,8 +601,7 @@ class SnowflakeCompiler(compiler.SQLCompiler):
             options_list.sort(key=operator.itemgetter(0))
         options = (
             (
-                " "
-                + " ".join(
+                " ".join(
                     [
                         "{} = {}".format(
                             n,
@@ -608,7 +622,7 @@ class SnowflakeCompiler(compiler.SQLCompiler):
             options += f" {credentials}"
         if encryption:
             options += f" {encryption}"
-        return f"COPY INTO {into} FROM {from_} {formatter}{options}"
+        return f"COPY INTO {into} FROM {' '.join([from_, partition_by, formatter, options])}"
 
     def visit_copy_formatter(self, formatter, **kw):
         options_list = list(formatter.options.items())

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/src/snowflake/sqlalchemy/custom_commands.py

@@ -115,18 +115,23 @@ class CopyInto(UpdateBase):
     __visit_name__ = "copy_into"
     _bind = None
 
-    def __init__(self, from_, into, formatter=None):
+    def __init__(self, from_, into, partition_by=None, formatter=None):
         self.from_ = from_
         self.into = into
         self.formatter = formatter
         self.copy_options = {}
+        self.partition_by = partition_by
 
     def __repr__(self):
         """
         repr for debugging / logging purposes only. For compilation logic, see
         the corresponding visitor in base.py
         """
-        return f"COPY INTO {self.into} FROM {repr(self.from_)} {repr(self.formatter)} ({self.copy_options})"
+        val = f"COPY INTO {self.into} FROM {repr(self.from_)}"
+        if self.partition_by is not None:
+            val += f" PARTITION BY {self.partition_by}"
+
+        return val + f" {repr(self.formatter)} ({self.copy_options})"
 
     def bind(self):
         return None

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/src/snowflake/sqlalchemy/snowdialect.py

@@ -39,6 +39,8 @@ from .custom_types import (
     _CUSTOM_Float,
     _CUSTOM_Time,
 )
+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_type
 from .sql.custom_schema.custom_table_prefix import CustomTablePrefix
 from .util import (

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/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.0"
+VERSION = "1.7.1"

{snowflake_sqlalchemy-1.7.0 → snowflake_sqlalchemy-1.7.1}/tests/test_copy.py

@@ -4,7 +4,7 @@
 
 import pytest
 from sqlalchemy import Column, Integer, MetaData, Sequence, String, Table
-from sqlalchemy.sql import select, text
+from sqlalchemy.sql import functions, select, text
 
 from snowflake.sqlalchemy import (
     AWSBucket,
@@ -58,8 +58,8 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     )
     assert (
         sql_compiler(copy_stmt_1)
-        == "COPY INTO 's3://backup' FROM python_tests_foods FILE_FORMAT=(TYPE=csv "
-        "ESCAPE=None NULL_IF=('null', 'Null') RECORD_DELIMITER='|') ENCRYPTION="
+        == "COPY INTO 's3://backup' FROM python_tests_foods  FILE_FORMAT=(TYPE=csv "
+        "ESCAPE=None NULL_IF=('null', 'Null') RECORD_DELIMITER='|')  ENCRYPTION="
         "(KMS_KEY_ID='1234abcd-12ab-34cd-56ef-1234567890ab' TYPE='AWS_SSE_KMS')"
     )
     copy_stmt_2 = CopyIntoStorage(
@@ -73,8 +73,8 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
         sql_compiler(copy_stmt_2)
         == "COPY INTO 's3://backup' FROM (SELECT python_tests_foods.id, "
         "python_tests_foods.name, python_tests_foods.quantity FROM python_tests_foods "
-        "WHERE python_tests_foods.id = 1) FILE_FORMAT=(TYPE=json COMPRESSION='zstd' "
-        "FILE_EXTENSION='json') CREDENTIALS=(AWS_ROLE='some_iam_role') "
+        "WHERE python_tests_foods.id = 1)  FILE_FORMAT=(TYPE=json COMPRESSION='zstd' "
+        "FILE_EXTENSION='json')  CREDENTIALS=(AWS_ROLE='some_iam_role') "
         "ENCRYPTION=(TYPE='AWS_SSE_S3')"
     )
     copy_stmt_3 = CopyIntoStorage(
@@ -87,7 +87,7 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     assert (
         sql_compiler(copy_stmt_3)
         == "COPY INTO 'azure://snowflake.blob.core.windows.net/snowpile/backup' "
-        "FROM python_tests_foods FILE_FORMAT=(TYPE=parquet SNAPPY_COMPRESSION=true) "
+        "FROM python_tests_foods  FILE_FORMAT=(TYPE=parquet SNAPPY_COMPRESSION=true)  "
         "CREDENTIALS=(AZURE_SAS_TOKEN='token')"
     )
 
@@ -95,7 +95,7 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     assert (
         sql_compiler(copy_stmt_3)
         == "COPY INTO 'azure://snowflake.blob.core.windows.net/snowpile/backup' "
-        "FROM python_tests_foods FILE_FORMAT=(TYPE=parquet SNAPPY_COMPRESSION=true) "
+        "FROM python_tests_foods  FILE_FORMAT=(TYPE=parquet SNAPPY_COMPRESSION=true) "
         "MAX_FILE_SIZE = 50000000 "
         "CREDENTIALS=(AZURE_SAS_TOKEN='token')"
     )
@@ -112,8 +112,8 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     )
     assert (
         sql_compiler(copy_stmt_4)
-        == "COPY INTO python_tests_foods FROM 's3://backup' FILE_FORMAT=(TYPE=csv "
-        "ESCAPE=None NULL_IF=('null', 'Null') RECORD_DELIMITER='|') ENCRYPTION="
+        == "COPY INTO python_tests_foods FROM 's3://backup'  FILE_FORMAT=(TYPE=csv "
+        "ESCAPE=None NULL_IF=('null', 'Null') RECORD_DELIMITER='|')  ENCRYPTION="
         "(KMS_KEY_ID='1234abcd-12ab-34cd-56ef-1234567890ab' TYPE='AWS_SSE_KMS')"
     )
 
@@ -126,8 +126,8 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     )
     assert (
         sql_compiler(copy_stmt_5)
-        == "COPY INTO python_tests_foods FROM 's3://backup' FILE_FORMAT=(TYPE=csv "
-        "FIELD_DELIMITER=',') ENCRYPTION="
+        == "COPY INTO python_tests_foods FROM 's3://backup'  FILE_FORMAT=(TYPE=csv "
+        "FIELD_DELIMITER=',')  ENCRYPTION="
         "(KMS_KEY_ID='1234abcd-12ab-34cd-56ef-1234567890ab' TYPE='AWS_SSE_KMS')"
     )
 
@@ -138,7 +138,7 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     )
     assert (
         sql_compiler(copy_stmt_6)
-        == "COPY INTO @stage_name FROM python_tests_foods FILE_FORMAT=(TYPE=csv)"
+        == "COPY INTO @stage_name FROM python_tests_foods  FILE_FORMAT=(TYPE=csv) "
     )
 
     copy_stmt_7 = CopyIntoStorage(
@@ -148,7 +148,38 @@ def test_copy_into_location(engine_testaccount, sql_compiler):
     )
     assert (
         sql_compiler(copy_stmt_7)
-        == "COPY INTO @name.stage_name/prefix/file FROM python_tests_foods FILE_FORMAT=(TYPE=csv)"
+        == "COPY INTO @name.stage_name/prefix/file FROM python_tests_foods  FILE_FORMAT=(TYPE=csv) "
+    )
+
+    copy_stmt_8 = CopyIntoStorage(
+        from_=food_items,
+        into=ExternalStage(name="stage_name"),
+        partition_by=text("('YEAR=' || year)"),
+    )
+    assert (
+        sql_compiler(copy_stmt_8)
+        == "COPY INTO @stage_name FROM python_tests_foods PARTITION BY ('YEAR=' || year)  "
+    )
+
+    copy_stmt_9 = CopyIntoStorage(
+        from_=food_items,
+        into=ExternalStage(name="stage_name"),
+        partition_by=functions.concat(
+            text("'YEAR='"), text(food_items.columns["name"].name)
+        ),
+    )
+    assert (
+        sql_compiler(copy_stmt_9)
+        == "COPY INTO @stage_name FROM python_tests_foods PARTITION BY concat('YEAR=', name)  "
+    )
+
+    copy_stmt_10 = CopyIntoStorage(
+        from_=food_items,
+        into=ExternalStage(name="stage_name"),
+        partition_by="",
+    )
+    assert (
+        sql_compiler(copy_stmt_10) == "COPY INTO @stage_name FROM python_tests_foods   "
     )
 
     # NOTE Other than expect known compiled text, submit it to RegressionTests environment and expect them to fail, but
@@ -231,7 +262,7 @@ def test_copy_into_storage_csv_extended(sql_compiler):
     result = sql_compiler(copy_into)
     expected = (
         r"COPY INTO TEST_IMPORT "
-        r"FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata "
+        r"FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata  "
         r"FILE_FORMAT=(TYPE=csv COMPRESSION='auto' DATE_FORMAT='AUTO' "
         r"ERROR_ON_COLUMN_COUNT_MISMATCH=True ESCAPE=None "
         r"ESCAPE_UNENCLOSED_FIELD='\134' FIELD_DELIMITER=',' "
@@ -288,7 +319,7 @@ def test_copy_into_storage_parquet_named_format(sql_compiler):
     expected = (
         "COPY INTO TEST_IMPORT "
         "FROM (SELECT $1:COL1::number, $1:COL2::varchar "
-        "FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata/out.parquet) "
+        "FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata/out.parquet)  "
         "FILE_FORMAT=(format_name = parquet_file_format) force = TRUE"
     )
     assert result == expected
@@ -350,7 +381,7 @@ def test_copy_into_storage_parquet_files(sql_compiler):
         "COPY INTO TEST_IMPORT "
         "FROM (SELECT $1:COL1::number, $1:COL2::varchar "
         "FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata/out.parquet "
-        "(file_format => parquet_file_format))  FILES = ('foo.txt','bar.txt') "
+        "(file_format => parquet_file_format))   FILES = ('foo.txt','bar.txt') "
         "FORCE = true"
     )
     assert result == expected
@@ -412,6 +443,6 @@ def test_copy_into_storage_parquet_pattern(sql_compiler):
         "COPY INTO TEST_IMPORT "
         "FROM (SELECT $1:COL1::number, $1:COL2::varchar "
         "FROM @ML_POC.PUBLIC.AZURE_STAGE/testdata/out.parquet "
-        "(file_format => parquet_file_format))  FORCE = true PATTERN = '.*csv'"
+        "(file_format => parquet_file_format))   FORCE = true PATTERN = '.*csv'"
     )
     assert result == expected

snowflake_sqlalchemy-1.7.1/tests/test_imports.py

@@ -0,0 +1,64 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+
+import importlib
+import inspect
+
+import pytest
+
+
+def get_classes_from_module(module_name):
+    """Returns a set of class names from a given module."""
+    try:
+        module = importlib.import_module(module_name)
+        members = inspect.getmembers(module)
+        return {name for name, obj in members if inspect.isclass(obj)}
+
+    except ImportError:
+        print(f"Module '{module_name}' could not be imported.")
+        return set()
+
+
+def test_types_in_snowdialect():
+    classes_a = get_classes_from_module(
+        "snowflake.sqlalchemy.parser.custom_type_parser"
+    )
+    classes_b = get_classes_from_module("snowflake.sqlalchemy.snowdialect")
+    assert classes_a.issubset(classes_b), str(classes_a - classes_b)
+
+
+@pytest.mark.parametrize(
+    "type_class_name",
+    [
+        "BIGINT",
+        "BINARY",
+        "BOOLEAN",
+        "CHAR",
+        "DATE",
+        "DATETIME",
+        "DECIMAL",
+        "FLOAT",
+        "INTEGER",
+        "REAL",
+        "SMALLINT",
+        "TIME",
+        "TIMESTAMP",
+        "VARCHAR",
+        "NullType",
+        "_CUSTOM_DECIMAL",
+        "ARRAY",
+        "DOUBLE",
+        "GEOGRAPHY",
+        "GEOMETRY",
+        "MAP",
+        "OBJECT",
+        "TIMESTAMP_LTZ",
+        "TIMESTAMP_NTZ",
+        "TIMESTAMP_TZ",
+        "VARIANT",
+    ],
+)
+def test_snowflake_data_types_instance(type_class_name):
+    classes_b = get_classes_from_module("snowflake.sqlalchemy.snowdialect")
+    assert type_class_name in classes_b, type_class_name