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

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.1}/.pre-commit-config.yaml

@@ -4,6 +4,7 @@ repos:
     rev: v4.5.0
     hooks:
     -   id: trailing-whitespace
+        exclude: '\.ambr$'
     -   id: end-of-file-fixer
     -   id: check-yaml
         exclude: .github/repo_meta.yaml

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

@@ -9,6 +9,21 @@ Source code is also available at:
 
 # Release Notes
 
+- 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
+  - Fixed SAWarning when registering functions with existing name in default namespace
+  - Update options to be defined in key arguments instead of arguments.
+  - Add support for refresh_mode option in DynamicTable
+  - Add support for iceberg table with Snowflake Catalog
+  - Fix cluster by option to support explicit expressions
+  - Add support for MAP datatype
+
 - v1.6.1(July 9, 2024)
 
   - Update internal project workflow with pypi publishing
@@ -24,7 +39,7 @@ Source code is also available at:
 
 - v1.5.3(April 16, 2024)
 
-    - Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0
+  - Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0
 
 - v1.5.2(April 11, 2024)
 
@@ -33,7 +48,7 @@ Source code is also available at:
 
 - v1.5.1(November 03, 2023)
 
-  - Fixed a compatibility issue with Snowflake Behavioral Change 1057 on outer lateral join, for more details check https://docs.snowflake.com/en/release-notes/bcr-bundles/2023_04/bcr-1057.
+  - Fixed a compatibility issue with Snowflake Behavioral Change 1057 on outer lateral join, for more details check <https://docs.snowflake.com/en/release-notes/bcr-bundles/2023_04/bcr-1057>.
   - Fixed credentials with `externalbrowser` authentication not caching due to incorrect parsing of boolean query parameters.
     - This fixes other boolean parameter passing to driver as well.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-sqlalchemy
-Version: 1.6.1
+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
@@ -8,8 +8,7 @@ Project-URL: Homepage, https://www.snowflake.com/
 Project-URL: Issues, https://github.com/snowflakedb/snowflake-sqlalchemy/issues
 Project-URL: Source, https://github.com/snowflakedb/snowflake-sqlalchemy
 Author-email: "Snowflake Inc." <triage-snowpark-python-api-dl@snowflake.com>
-License-Expression: Apache-2.0
-License-File: LICENSE.txt
+License: Apache-2.0
 Keywords: Snowflake,analytics,cloud,database,db,warehouse
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
@@ -46,6 +45,7 @@ Requires-Dist: pytest-cov; extra == 'development'
 Requires-Dist: pytest-rerunfailures; extra == 'development'
 Requires-Dist: pytest-timeout; extra == 'development'
 Requires-Dist: pytz; extra == 'development'
+Requires-Dist: syrupy==4.6.1; extra == 'development'
 Provides-Extra: pandas
 Requires-Dist: snowflake-connector-python[pandas]; extra == 'pandas'
 Description-Content-Type: text/markdown
@@ -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
 
@@ -392,7 +429,7 @@ This example shows how to create a table with two columns, `id` and `name`, as t
 t = Table('myuser', metadata,
     Column('id', Integer, primary_key=True),
     Column('name', String),
-    snowflake_clusterby=['id', 'name'], ...
+    snowflake_clusterby=['id', 'name', text('id > 5')], ...
 )
 metadata.create_all(engine)
 ```
@@ -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.6.1 → 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
 
@@ -340,7 +377,7 @@ This example shows how to create a table with two columns, `id` and `name`, as t
 t = Table('myuser', metadata,
     Column('id', Integer, primary_key=True),
     Column('name', String),
-    snowflake_clusterby=['id', 'name'], ...
+    snowflake_clusterby=['id', 'name', text('id > 5')], ...
 )
 metadata.create_all(engine)
 ```
@@ -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.6.1 → snowflake_sqlalchemy-1.7.1}/pyproject.toml

@@ -53,6 +53,7 @@ development = [
   "pytz",
   "numpy",
   "mock",
+  "syrupy==4.6.1",
 ]
 pandas = ["snowflake-connector-python[pandas]"]
 
@@ -91,6 +92,7 @@ SQLACHEMY_WARN_20 = "1"
 check = "pre-commit run --all-files"
 test-dialect = "pytest -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
 test-dialect-compatibility = "pytest -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml tests/sqlalchemy_test_suite"
+test-dialect-aws = "pytest -m \"aws\" -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
 gh-cache-sum = "python -VV | sha256sum | cut -d' ' -f1"
 check-import = "python -c 'import snowflake.sqlalchemy; print(snowflake.sqlalchemy.__version__)'"
 
@@ -109,6 +111,7 @@ line-length = 88
 line-length = 88
 
 [tool.pytest.ini_options]
+addopts = "-m 'not feature_max_lob_size and not aws and not requires_external_volume'"
 markers = [
   # Optional dependency groups markers
   "lambda: AWS lambda tests",
@@ -125,5 +128,7 @@ markers = [
   # Other markers
   "timeout: tests that need a timeout time",
   "internal: tests that could but should only run on our internal CI",
+  "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",
 ]

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.1}/src/snowflake/sqlalchemy/__init__.py

@@ -9,7 +9,7 @@ if sys.version_info < (3, 8):
 else:
     import importlib.metadata as importlib_metadata
 
-from sqlalchemy.types import (
+from sqlalchemy.types import (  # noqa
     BIGINT,
     BINARY,
     BOOLEAN,
@@ -27,8 +27,8 @@ from sqlalchemy.types import (
     VARCHAR,
 )
 
-from . import base, snowdialect
-from .custom_commands import (
+from . import base, snowdialect  # noqa
+from .custom_commands import (  # noqa
     AWSBucket,
     AzureContainer,
     CopyFormatter,
@@ -41,7 +41,7 @@ from .custom_commands import (
     MergeInto,
     PARQUETFormatter,
 )
-from .custom_types import (
+from .custom_types import (  # noqa
     ARRAY,
     BYTEINT,
     CHARACTER,
@@ -50,6 +50,7 @@ from .custom_types import (
     FIXED,
     GEOGRAPHY,
     GEOMETRY,
+    MAP,
     NUMBER,
     OBJECT,
     STRING,
@@ -61,13 +62,30 @@ from .custom_types import (
     VARBINARY,
     VARIANT,
 )
-from .util import _url as URL
+from .sql.custom_schema import (  # noqa
+    DynamicTable,
+    HybridTable,
+    IcebergTable,
+    SnowflakeTable,
+)
+from .sql.custom_schema.options import (  # noqa
+    AsQueryOption,
+    ClusterByOption,
+    IdentifierOption,
+    KeywordOption,
+    LiteralOption,
+    SnowflakeKeyword,
+    TableOptionKey,
+    TargetLagOption,
+    TimeUnit,
+)
+from .util import _url as URL  # noqa
 
 base.dialect = dialect = snowdialect.dialect
 
 __version__ = importlib_metadata.version("snowflake-sqlalchemy")
 
-__all__ = (
+_custom_types = (
     "BIGINT",
     "BINARY",
     "BOOLEAN",
@@ -102,6 +120,10 @@ __all__ = (
     "TINYINT",
     "VARBINARY",
     "VARIANT",
+    "MAP",
+)
+
+_custom_commands = (
     "MergeInto",
     "CSVFormatter",
     "JSONFormatter",
@@ -114,3 +136,27 @@ __all__ = (
     "CreateStage",
     "CreateFileFormat",
 )
+
+_custom_tables = ("HybridTable", "DynamicTable", "IcebergTable", "SnowflakeTable")
+
+_custom_table_options = (
+    "AsQueryOption",
+    "TargetLagOption",
+    "LiteralOption",
+    "IdentifierOption",
+    "KeywordOption",
+    "ClusterByOption",
+)
+
+_enums = (
+    "TimeUnit",
+    "TableOptionKey",
+    "SnowflakeKeyword",
+)
+__all__ = (
+    *_custom_types,
+    *_custom_commands,
+    *_custom_tables,
+    *_custom_table_options,
+    *_enums,
+)

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.1}/src/snowflake/sqlalchemy/_constants.py

@@ -10,3 +10,5 @@ PARAM_INTERNAL_APPLICATION_VERSION = "internal_application_version"
 
 APPLICATION_NAME = "SnowflakeSQLAlchemy"
 SNOWFLAKE_SQLALCHEMY_VERSION = VERSION
+DIALECT_NAME = "snowflake"
+NOT_NULL = "NOT NULL"