snowflake-sqlalchemy 1.8.2__tar.gz → 1.9.0__tar.gz

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/DESCRIPTION.md

@@ -11,6 +11,23 @@ Source code is also available at:
 
 # Release Notes
 
+- v1.9.0 (March 4, 2026)
+  - Add support for `DECFLOAT` and `VECTOR` data types
+  - Add server_version_info support
+  - Add support for `ILIKE` in queries
+  - Fix `SYSDATE()` rendering
+  - Fix and improve schema reflection (SNOW-593204, SNOW-2331576, SNOW-2852779)
+    - Fix crash when reflecting without specifying a schema, caused by `None` arguments in internal schema resolution ([#623](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/623)).
+    - Fix crash when `SHOW TABLES` returns empty string table names, causing `IndexError` during reflection ([#296](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/296)).
+    - Fix incomplete identity column reflection metadata, now includes all fields required by SQLAlchemy 2.0+ (`always`, `cycle`, `order`, etc.).
+    - Introduce shared helper for fully-qualified schema name resolution, replacing inconsistent ad-hoc patterns across reflection methods.
+    - Refactor column reflection internals into dedicated helpers to reduce complexity without changing behavior.
+    - Add `pytest-xdist` parallel test support via per-worker schema provisioning hooks.
+  - Bump `pandas` lower bound in `sa14` test environment from `<2.1` to `>=2.1.1,<2.2` to ensure pre-built wheels are available for Python 3.12
+  - Fix SQLAlchemy version parsing (SNOW-3066571)
+  - Document support for session parameters (like [QUERY_TAG](https://docs.snowflake.com/en/sql-reference/parameters#query-tag)), references: [#644](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/495)
+  - Support timezone in timestamp and datetime types ([#199](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/199))
+
 - v1.8.2 (December 9, 2025)
   - Updated supported max python version to 3.13
   - Version 1.8.1 yanked due to max python version supported by `snowflake-connector-python`

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.8.2
+Version: 1.9.0
 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
@@ -39,7 +39,6 @@ Requires-Python: >=3.8
 Requires-Dist: snowflake-connector-python<5.0.0
 Requires-Dist: sqlalchemy>=1.4.19
 Provides-Extra: development
-Requires-Dist: mock; extra == 'development'
 Requires-Dist: numpy; extra == 'development'
 Requires-Dist: pre-commit; extra == 'development'
 Requires-Dist: pytest; extra == 'development'
@@ -64,7 +63,47 @@ 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.
 
-
+Table of contents:
+<!-- TOC -->
+* [Snowflake SQLAlchemy](#snowflake-sqlalchemy)
+  * [Prerequisites](#prerequisites)
+    * [Snowflake Connector for Python](#snowflake-connector-for-python)
+    * [Data Analytics and Web Application Frameworks (Optional)](#data-analytics-and-web-application-frameworks-optional)
+  * [Installing Snowflake SQLAlchemy](#installing-snowflake-sqlalchemy)
+  * [Verifying Your Installation](#verifying-your-installation)
+  * [Parameters and Behavior](#parameters-and-behavior)
+    * [Connection Parameters](#connection-parameters)
+      * [Escaping Special Characters such as `%, @` signs in Passwords](#escaping-special-characters-such-as---signs-in-passwords)
+      * [Using a proxy server](#using-a-proxy-server)
+      * [Using session parameters](#using-session-parameters)
+    * [Opening and Closing Connection](#opening-and-closing-connection)
+    * [Auto-increment Behavior](#auto-increment-behavior)
+    * [Object Name Case Handling](#object-name-case-handling)
+    * [Index Support](#index-support)
+      * [Single Column Index](#single-column-index)
+      * [Multi-Column Index](#multi-column-index)
+    * [Numpy Data Type Support](#numpy-data-type-support)
+    * [DECFLOAT Data Type Support](#decfloat-data-type-support)
+      * [DECFLOAT Precision](#decfloat-precision)
+    * [VECTOR Data Type Support](#vector-data-type-support)
+    * [Cache Column Metadata](#cache-column-metadata)
+    * [VARIANT, ARRAY and OBJECT Support](#variant-array-and-object-support)
+    * [Structured Data Types Support](#structured-data-types-support)
+      * [MAP](#map)
+      * [OBJECT](#object)
+      * [ARRAY](#array)
+    * [CLUSTER BY Support](#cluster-by-support)
+    * [Alembic Support](#alembic-support)
+    * [Key Pair Authentication Support](#key-pair-authentication-support)
+    * [Merge Command Support](#merge-command-support)
+    * [CopyIntoStorage Support](#copyintostorage-support)
+    * [Iceberg Table with Snowflake Catalog support](#iceberg-table-with-snowflake-catalog-support)
+    * [Hybrid Table support](#hybrid-table-support)
+    * [Dynamic Tables support](#dynamic-tables-support)
+    * [Notes](#notes)
+  * [Verifying Package Signatures](#verifying-package-signatures)
+  * [Support](#support)
+<!-- TOC -->
 
 ## Prerequisites
 
@@ -240,6 +279,44 @@ engine = create_engine(URL(
 
 Use the supported environment variables, `HTTPS_PROXY`, `HTTP_PROXY` and `NO_PROXY` to configure a proxy server.
 
+#### Using session parameters
+
+Snowflake [session parameters](https://docs.snowflake.com/en/sql-reference/parameters#session-parameters) (such as [`QUERY_TAG`](https://docs.snowflake.com/en/sql-reference/parameters#query-tag)) cannot be set directly through the `URL` helper.
+Instead, pass them via the `connect_args` parameter of `create_engine`, using the `session_parameters` dict — the same way you would [through the Python connector](https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-session-parameters):
+
+```python
+from snowflake.sqlalchemy import URL
+from sqlalchemy import create_engine
+
+engine = create_engine(
+    URL(
+        # CONNECTION_PARAMETERS
+    ),
+    connect_args={
+        "session_parameters": {
+            "QUERY_TAG": "SOME_QUERY_TAGS",
+        }
+    },
+)
+```
+
+Session parameters set this way apply to all queries executed within the session.
+To change a session parameter for specific queries mid-session, use `ALTER SESSION`:
+
+```python
+from sqlalchemy import text
+
+with engine.connect() as conn:
+    conn.execute(text("ALTER SESSION SET QUERY_TAG = 'batch_job_1'"))
+    conn.execute(text("..."))  # Uses 'batch_job_1'
+
+    conn.execute(text("ALTER SESSION SET QUERY_TAG = 'batch_job_2'"))
+    conn.execute(text("..."))  # Uses 'batch_job_2'
+
+    conn.execute(text("ALTER SESSION UNSET QUERY_TAG"))
+    conn.execute(text("..."))  # No tag
+```
+
 ### Opening and Closing Connection
 
 Open a connection by executing `engine.connect()`; avoid using `engine.execute()`. Make certain to close the connection by executing `connection.close()` before
@@ -359,6 +436,116 @@ The following `NumPy` data types are supported:
 - numpy.float64
 - numpy.datatime64
 
+### DECFLOAT Data Type Support
+
+Snowflake SQLAlchemy supports the `DECFLOAT` data type, which provides decimal floating-point with up to 38 significant digits. For more information, see the [Snowflake DECFLOAT documentation](https://docs.snowflake.com/en/sql-reference/data-types-numeric#decfloat).
+
+```python
+from sqlalchemy import Column, Integer, MetaData, Table
+from snowflake.sqlalchemy import DECFLOAT
+
+metadata = MetaData()
+t = Table('my_table', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('value', DECFLOAT()),
+)
+metadata.create_all(engine)
+```
+
+#### DECFLOAT Precision
+
+The Snowflake Python connector uses Python's `decimal` module context when converting `DECFLOAT` values to Python `Decimal` objects. Python's default decimal context precision is 28 digits, which can truncate `DECFLOAT` values that use up to 38 digits.
+
+To preserve full 38-digit precision, add `enable_decfloat=True` to the connection URL:
+
+```python
+from sqlalchemy import create_engine
+
+engine = create_engine(
+    'snowflake://testuser1:0123456@abc123/testdb/public?warehouse=testwh&enable_decfloat=True'
+)
+```
+
+Or using the `snowflake.sqlalchemy.URL` helper:
+
+```python
+from snowflake.sqlalchemy import URL
+from sqlalchemy import create_engine
+
+engine = create_engine(URL(
+    account = 'abc123',
+    user = 'testuser1',
+    password = '0123456',
+    database = 'testdb',
+    schema = 'public',
+    warehouse = 'testwh',
+    enable_decfloat = True,
+))
+```
+
+**Note**: `DECFLOAT` does not support special values (`inf`, `-inf`, `NaN`) unlike `FLOAT`.
+
+**Why is `enable_decfloat` not enabled by default?** Enabling it sets `decimal.getcontext().prec = 38`, which modifies Python's thread-local decimal context and affects all `Decimal` operations in that thread, not just database queries. To avoid unexpected side effects on application code, the dialect emits a warning when `DECFLOAT` values are retrieved without full precision enabled, guiding users to opt-in explicitly.
+
+### VECTOR Data Type Support
+
+Snowflake SQLAlchemy supports the `VECTOR` data type with varying element type and dimension.
+For more information, see the [Snowflake documentation](https://docs.snowflake.com/en/sql-reference/data-types-vector).
+
+```python
+from sqlalchemy import Column, Integer, Float, MetaData, Table
+from snowflake.sqlalchemy import VECTOR
+
+metadata = MetaData()
+t = Table('my_table', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('int_vec', VECTOR(Integer, 20)),
+    Column('float_vec', VECTOR(Float, 40)),
+)
+metadata.create_all(engine)
+```
+
+### Timestamp and Timezone Support
+
+Snowflake SQLAlchemy provides three Snowflake-specific timestamp types that map directly to their Snowflake counterparts:
+
+```python
+from sqlalchemy import Column, Integer, MetaData, Table, create_engine
+from snowflake.sqlalchemy import TIMESTAMP_NTZ, TIMESTAMP_TZ, TIMESTAMP_LTZ
+
+engine = create_engine(...)
+metadata = MetaData()
+t = Table('events', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('created_at', TIMESTAMP_NTZ()),   # TIMESTAMP WITHOUT TIME ZONE
+    Column('scheduled_at', TIMESTAMP_TZ()),  # TIMESTAMP WITH TIME ZONE
+    Column('logged_at', TIMESTAMP_LTZ()),    # TIMESTAMP WITH LOCAL TIME ZONE
+)
+metadata.create_all(engine)
+```
+
+SQLAlchemy's generic `DateTime` and `TIMESTAMP` types also support timezone-aware columns via the `timezone` parameter. When `timezone=True` is set, the dialect emits `TIMESTAMP_TZ` instead of the default `TIMESTAMP_NTZ`:
+
+```python
+from sqlalchemy import Column, DateTime, Integer, MetaData, Table, create_engine
+from sqlalchemy.types import TIMESTAMP
+
+engine = create_engine(...)
+metadata = MetaData()
+t = Table('events', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('naive_ts', DateTime()),                 # produces TIMESTAMP_NTZ
+    Column('aware_ts', DateTime(timezone=True)),    # produces TIMESTAMP_TZ
+    Column('naive_ts2', TIMESTAMP()),               # produces TIMESTAMP_NTZ
+    Column('aware_ts2', TIMESTAMP(timezone=True)),  # produces TIMESTAMP_TZ
+)
+metadata.create_all(engine)
+```
+
+This also applies when using pandas `to_sql()` with timezone-aware datetime columns, which infers `DateTime(timezone=True)` automatically (see [#199](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/199)).
+
+**Note on `Time` and timezones:** SQLAlchemy's `Time` type accepts a `timezone` parameter, but [Snowflake's TIME data type does not support time zones](https://docs.snowflake.com/en/sql-reference/data-types-datetime#time). Using `Time(timezone=True)` will compile to plain `TIME` and the `timezone` flag will have no effect. If you need to store time data with time-zone information, use a timestamp type such as `TIMESTAMP_TZ` or `DateTime(timezone=True)` instead.
+
 ### Cache Column Metadata
 
 SQLAlchemy provides [the runtime inspection API](http://docs.sqlalchemy.org/en/latest/core/inspection.html) to get the runtime information about the various objects. One of the common use case is get all tables and their column metadata in a schema in order to construct a schema catalog. For example, [alembic](http://alembic.zzzcomputing.com/) on top of SQLAlchemy manages database schema migrations. A pseudo code flow is as follows:

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/README.md

@@ -8,7 +8,47 @@
 
 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.
 
-
+Table of contents:
+<!-- TOC -->
+* [Snowflake SQLAlchemy](#snowflake-sqlalchemy)
+  * [Prerequisites](#prerequisites)
+    * [Snowflake Connector for Python](#snowflake-connector-for-python)
+    * [Data Analytics and Web Application Frameworks (Optional)](#data-analytics-and-web-application-frameworks-optional)
+  * [Installing Snowflake SQLAlchemy](#installing-snowflake-sqlalchemy)
+  * [Verifying Your Installation](#verifying-your-installation)
+  * [Parameters and Behavior](#parameters-and-behavior)
+    * [Connection Parameters](#connection-parameters)
+      * [Escaping Special Characters such as `%, @` signs in Passwords](#escaping-special-characters-such-as---signs-in-passwords)
+      * [Using a proxy server](#using-a-proxy-server)
+      * [Using session parameters](#using-session-parameters)
+    * [Opening and Closing Connection](#opening-and-closing-connection)
+    * [Auto-increment Behavior](#auto-increment-behavior)
+    * [Object Name Case Handling](#object-name-case-handling)
+    * [Index Support](#index-support)
+      * [Single Column Index](#single-column-index)
+      * [Multi-Column Index](#multi-column-index)
+    * [Numpy Data Type Support](#numpy-data-type-support)
+    * [DECFLOAT Data Type Support](#decfloat-data-type-support)
+      * [DECFLOAT Precision](#decfloat-precision)
+    * [VECTOR Data Type Support](#vector-data-type-support)
+    * [Cache Column Metadata](#cache-column-metadata)
+    * [VARIANT, ARRAY and OBJECT Support](#variant-array-and-object-support)
+    * [Structured Data Types Support](#structured-data-types-support)
+      * [MAP](#map)
+      * [OBJECT](#object)
+      * [ARRAY](#array)
+    * [CLUSTER BY Support](#cluster-by-support)
+    * [Alembic Support](#alembic-support)
+    * [Key Pair Authentication Support](#key-pair-authentication-support)
+    * [Merge Command Support](#merge-command-support)
+    * [CopyIntoStorage Support](#copyintostorage-support)
+    * [Iceberg Table with Snowflake Catalog support](#iceberg-table-with-snowflake-catalog-support)
+    * [Hybrid Table support](#hybrid-table-support)
+    * [Dynamic Tables support](#dynamic-tables-support)
+    * [Notes](#notes)
+  * [Verifying Package Signatures](#verifying-package-signatures)
+  * [Support](#support)
+<!-- TOC -->
 
 ## Prerequisites
 
@@ -184,6 +224,44 @@ engine = create_engine(URL(
 
 Use the supported environment variables, `HTTPS_PROXY`, `HTTP_PROXY` and `NO_PROXY` to configure a proxy server.
 
+#### Using session parameters
+
+Snowflake [session parameters](https://docs.snowflake.com/en/sql-reference/parameters#session-parameters) (such as [`QUERY_TAG`](https://docs.snowflake.com/en/sql-reference/parameters#query-tag)) cannot be set directly through the `URL` helper.
+Instead, pass them via the `connect_args` parameter of `create_engine`, using the `session_parameters` dict — the same way you would [through the Python connector](https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-session-parameters):
+
+```python
+from snowflake.sqlalchemy import URL
+from sqlalchemy import create_engine
+
+engine = create_engine(
+    URL(
+        # CONNECTION_PARAMETERS
+    ),
+    connect_args={
+        "session_parameters": {
+            "QUERY_TAG": "SOME_QUERY_TAGS",
+        }
+    },
+)
+```
+
+Session parameters set this way apply to all queries executed within the session.
+To change a session parameter for specific queries mid-session, use `ALTER SESSION`:
+
+```python
+from sqlalchemy import text
+
+with engine.connect() as conn:
+    conn.execute(text("ALTER SESSION SET QUERY_TAG = 'batch_job_1'"))
+    conn.execute(text("..."))  # Uses 'batch_job_1'
+
+    conn.execute(text("ALTER SESSION SET QUERY_TAG = 'batch_job_2'"))
+    conn.execute(text("..."))  # Uses 'batch_job_2'
+
+    conn.execute(text("ALTER SESSION UNSET QUERY_TAG"))
+    conn.execute(text("..."))  # No tag
+```
+
 ### Opening and Closing Connection
 
 Open a connection by executing `engine.connect()`; avoid using `engine.execute()`. Make certain to close the connection by executing `connection.close()` before
@@ -303,6 +381,116 @@ The following `NumPy` data types are supported:
 - numpy.float64
 - numpy.datatime64
 
+### DECFLOAT Data Type Support
+
+Snowflake SQLAlchemy supports the `DECFLOAT` data type, which provides decimal floating-point with up to 38 significant digits. For more information, see the [Snowflake DECFLOAT documentation](https://docs.snowflake.com/en/sql-reference/data-types-numeric#decfloat).
+
+```python
+from sqlalchemy import Column, Integer, MetaData, Table
+from snowflake.sqlalchemy import DECFLOAT
+
+metadata = MetaData()
+t = Table('my_table', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('value', DECFLOAT()),
+)
+metadata.create_all(engine)
+```
+
+#### DECFLOAT Precision
+
+The Snowflake Python connector uses Python's `decimal` module context when converting `DECFLOAT` values to Python `Decimal` objects. Python's default decimal context precision is 28 digits, which can truncate `DECFLOAT` values that use up to 38 digits.
+
+To preserve full 38-digit precision, add `enable_decfloat=True` to the connection URL:
+
+```python
+from sqlalchemy import create_engine
+
+engine = create_engine(
+    'snowflake://testuser1:0123456@abc123/testdb/public?warehouse=testwh&enable_decfloat=True'
+)
+```
+
+Or using the `snowflake.sqlalchemy.URL` helper:
+
+```python
+from snowflake.sqlalchemy import URL
+from sqlalchemy import create_engine
+
+engine = create_engine(URL(
+    account = 'abc123',
+    user = 'testuser1',
+    password = '0123456',
+    database = 'testdb',
+    schema = 'public',
+    warehouse = 'testwh',
+    enable_decfloat = True,
+))
+```
+
+**Note**: `DECFLOAT` does not support special values (`inf`, `-inf`, `NaN`) unlike `FLOAT`.
+
+**Why is `enable_decfloat` not enabled by default?** Enabling it sets `decimal.getcontext().prec = 38`, which modifies Python's thread-local decimal context and affects all `Decimal` operations in that thread, not just database queries. To avoid unexpected side effects on application code, the dialect emits a warning when `DECFLOAT` values are retrieved without full precision enabled, guiding users to opt-in explicitly.
+
+### VECTOR Data Type Support
+
+Snowflake SQLAlchemy supports the `VECTOR` data type with varying element type and dimension.
+For more information, see the [Snowflake documentation](https://docs.snowflake.com/en/sql-reference/data-types-vector).
+
+```python
+from sqlalchemy import Column, Integer, Float, MetaData, Table
+from snowflake.sqlalchemy import VECTOR
+
+metadata = MetaData()
+t = Table('my_table', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('int_vec', VECTOR(Integer, 20)),
+    Column('float_vec', VECTOR(Float, 40)),
+)
+metadata.create_all(engine)
+```
+
+### Timestamp and Timezone Support
+
+Snowflake SQLAlchemy provides three Snowflake-specific timestamp types that map directly to their Snowflake counterparts:
+
+```python
+from sqlalchemy import Column, Integer, MetaData, Table, create_engine
+from snowflake.sqlalchemy import TIMESTAMP_NTZ, TIMESTAMP_TZ, TIMESTAMP_LTZ
+
+engine = create_engine(...)
+metadata = MetaData()
+t = Table('events', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('created_at', TIMESTAMP_NTZ()),   # TIMESTAMP WITHOUT TIME ZONE
+    Column('scheduled_at', TIMESTAMP_TZ()),  # TIMESTAMP WITH TIME ZONE
+    Column('logged_at', TIMESTAMP_LTZ()),    # TIMESTAMP WITH LOCAL TIME ZONE
+)
+metadata.create_all(engine)
+```
+
+SQLAlchemy's generic `DateTime` and `TIMESTAMP` types also support timezone-aware columns via the `timezone` parameter. When `timezone=True` is set, the dialect emits `TIMESTAMP_TZ` instead of the default `TIMESTAMP_NTZ`:
+
+```python
+from sqlalchemy import Column, DateTime, Integer, MetaData, Table, create_engine
+from sqlalchemy.types import TIMESTAMP
+
+engine = create_engine(...)
+metadata = MetaData()
+t = Table('events', metadata,
+    Column('id', Integer, primary_key=True),
+    Column('naive_ts', DateTime()),                 # produces TIMESTAMP_NTZ
+    Column('aware_ts', DateTime(timezone=True)),    # produces TIMESTAMP_TZ
+    Column('naive_ts2', TIMESTAMP()),               # produces TIMESTAMP_NTZ
+    Column('aware_ts2', TIMESTAMP(timezone=True)),  # produces TIMESTAMP_TZ
+)
+metadata.create_all(engine)
+```
+
+This also applies when using pandas `to_sql()` with timezone-aware datetime columns, which infers `DateTime(timezone=True)` automatically (see [#199](https://github.com/snowflakedb/snowflake-sqlalchemy/issues/199)).
+
+**Note on `Time` and timezones:** SQLAlchemy's `Time` type accepts a `timezone` parameter, but [Snowflake's TIME data type does not support time zones](https://docs.snowflake.com/en/sql-reference/data-types-datetime#time). Using `Time(timezone=True)` will compile to plain `TIME` and the `timezone` flag will have no effect. If you need to store time data with time-zone information, use a timestamp type such as `TIMESTAMP_TZ` or `DateTime(timezone=True)` instead.
+
 ### Cache Column Metadata
 
 SQLAlchemy provides [the runtime inspection API](http://docs.sqlalchemy.org/en/latest/core/inspection.html) to get the runtime information about the various objects. One of the common use case is get all tables and their column metadata in a schema in order to construct a schema catalog. For example, [alembic](http://alembic.zzzcomputing.com/) on top of SQLAlchemy manages database schema migrations. A pseudo code flow is as follows:

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/ci/build.sh

@@ -22,5 +22,5 @@ echo "[Info] Building snowflake-sqlalchemy with $PYTHON"
 # Clean up possible build artifacts
 rm -rf build generated_version.py
 export UV_NO_CACHE=true
-${PYTHON} -m pip install uv hatch
-${PYTHON} -m hatch build
+${PYTHON} -m pip install uv
+${PYTHON} -m uv build

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/ci/test_linux.sh

@@ -7,6 +7,8 @@
 #   - This is the script that test_docker.sh runs inside of the docker container
 
 PYTHON_VERSIONS="${1:-3.8 3.9 3.10 3.11 3.12 3.13 3.14}"
+# Python versions where pyarrow (required by pandas extra) is not available
+PANDAS_SKIP_VERSIONS="3.14"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 
@@ -19,7 +21,12 @@ for PYTHON_VERSION in ${PYTHON_VERSIONS}; do
   echo "[Info] Testing with ${PYTHON_VERSION}"
   SHORT_VERSION=$(python3 -c "print('${PYTHON_VERSION}'.replace('.', ''))")
   SQLALCHEMY_WHL=$(ls $SQLALCHEMY_DIR/dist/snowflake_sqlalchemy-*-py3-none-any.whl | sort -r | head -n 1)
-  TEST_ENVLIST=fix_lint,py${SHORT_VERSION}-ci,py${SHORT_VERSION}-coverage,py${SHORT_VERSION}-pandas-ci,py${SHORT_VERSION}-pandas-coverage
+  TEST_ENVLIST=fix_lint,py${SHORT_VERSION}-ci
+  if [[ ! " ${PANDAS_SKIP_VERSIONS} " =~ " ${PYTHON_VERSION} " ]]; then
+    TEST_ENVLIST="${TEST_ENVLIST},py${SHORT_VERSION}-pandas-ci"
+  else
+    echo "[Info] Skipping pandas tests for Python ${PYTHON_VERSION} (pyarrow not available)"
+  fi
   echo "[Info] Running tox for ${TEST_ENVLIST}"
-  python3 -m tox -e ${TEST_ENVLIST} --installpkg ${SQLALCHEMY_WHL}
+  python3 -m tox -p auto --parallel-no-spinner -e ${TEST_ENVLIST} --installpkg ${SQLALCHEMY_WHL}
 done

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/pyproject.toml

@@ -55,7 +55,6 @@ development = [
   "pytest-xdist",
   "pytz",
   "numpy",
-  "mock",
   "syrupy",
 ]
 pandas = ["snowflake-connector-python[pandas]"]
@@ -85,7 +84,11 @@ installer = "uv"
 [tool.hatch.envs.sa14]
 installer = "uv"
 builder = true
-extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0", "pandas<2.1", "numpy<2"]
+extra-dependencies = [
+  "SQLAlchemy>=1.4.19,<2.0.0",
+  "pandas>=2.1.1,<2.2",
+  "numpy<2",
+]
 features = ["development", "pandas"]
 python = "3.12"
 
@@ -142,4 +145,5 @@ markers = [
   "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",
+  "mypy: typing tests",
 ]

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/src/snowflake/sqlalchemy/__init__.py

@@ -46,6 +46,7 @@ from .custom_types import (  # noqa
     BYTEINT,
     CHARACTER,
     DEC,
+    DECFLOAT,
     DOUBLE,
     FIXED,
     GEOGRAPHY,
@@ -61,6 +62,7 @@ from .custom_types import (  # noqa
     TINYINT,
     VARBINARY,
     VARIANT,
+    VECTOR,
 )
 from .sql.custom_schema import (  # noqa
     DynamicTable,
@@ -93,6 +95,7 @@ _custom_types = (
     "DATE",
     "DATETIME",
     "DECIMAL",
+    "DECFLOAT",
     "FLOAT",
     "INT",
     "INTEGER",
@@ -120,6 +123,7 @@ _custom_types = (
     "TINYINT",
     "VARBINARY",
     "VARIANT",
+    "VECTOR",
     "MAP",
 )
 

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/src/snowflake/sqlalchemy/base.py

@@ -7,7 +7,7 @@ import operator
 import re
 import string
 import warnings
-from typing import List
+from typing import Any, List
 
 from sqlalchemy import exc as sa_exc
 from sqlalchemy import inspect, sql
@@ -16,7 +16,7 @@ from sqlalchemy.engine import default
 from sqlalchemy.orm import context
 from sqlalchemy.orm.context import _MapperEntity
 from sqlalchemy.schema import Sequence, Table
-from sqlalchemy.sql import compiler, expression, functions
+from sqlalchemy.sql import compiler, expression, functions, sqltypes
 from sqlalchemy.sql.base import CompileState
 from sqlalchemy.sql.elements import BindParameter, quoted_name
 from sqlalchemy.sql.expression import Executable
@@ -526,6 +526,9 @@ class SnowflakeCompiler(compiler.SQLCompiler):
     def visit_now_func(self, now, **kw):
         return "CURRENT_TIMESTAMP"
 
+    def visit_sysdate_func(self, sysdate, **kw):
+        return "SYSDATE()"
+
     def visit_merge_into(self, merge_into, **kw):
         clauses = " ".join(
             clause._compiler_dispatch(self, **kw) for clause in merge_into.clauses
@@ -779,6 +782,24 @@ class SnowflakeCompiler(compiler.SQLCompiler):
     def visit_not_regexp_match_op_binary(self, binary, operator, **kw):
         return f"NOT {self.visit_regexp_match_op_binary(binary, operator, **kw)}"
 
+    def visit_ilike_op_binary(self, binary, operator, **kw):
+        return self._render_ilike(binary, negate=False, **kw)
+
+    def visit_not_ilike_op_binary(self, binary, operator, **kw):
+        return self._render_ilike(binary, negate=True, **kw)
+
+    def _render_ilike(self, binary, negate=False, **kw):
+        left = binary.left._compiler_dispatch(self, **kw)
+        right = binary.right._compiler_dispatch(self, **kw)
+        escape = binary.modifiers.get("escape")
+        escape_clause = (
+            " ESCAPE " + self.render_literal_value(escape, sqltypes.STRINGTYPE)
+            if escape is not None
+            else ""
+        )
+        operator = "NOT ILIKE" if negate else "ILIKE"
+        return f"{left} {operator} {right}{escape_clause}"
+
     def visit_join(self, join, asfrom=False, from_linter=None, **kwargs):
         if from_linter:
             from_linter.edges.update(
@@ -1146,7 +1167,6 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
         else:
             contents = []
             for key in type_.items_types:
-
                 row_text = f"{key} {type_.items_types[key][0].compile()}"
                 # Type and not null is specified
                 if len(type_.items_types[key]) > 1:
@@ -1157,10 +1177,14 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
     def visit_BLOB(self, type_, **kw):
         return "BINARY"
 
-    def visit_datetime(self, type_, **kw):
+    def visit_datetime(self, type_: sqltypes.DateTime, **kw: Any) -> str:
+        if type_.timezone:
+            return "TIMESTAMP_TZ"
         return "datetime"
 
-    def visit_DATETIME(self, type_, **kw):
+    def visit_DATETIME(self, type_: sqltypes.DateTime, **kw: Any) -> str:
+        if type_.timezone:
+            return "TIMESTAMP_TZ"
         return "DATETIME"
 
     def visit_TIMESTAMP_NTZ(self, type_, **kw):
@@ -1172,7 +1196,9 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
     def visit_TIMESTAMP_LTZ(self, type_, **kw):
         return "TIMESTAMP_LTZ"
 
-    def visit_TIMESTAMP(self, type_, **kw):
+    def visit_TIMESTAMP(self, type_: sqltypes.TIMESTAMP, **kw: Any) -> str:
+        if type_.timezone:
+            return "TIMESTAMP_TZ"
         return "TIMESTAMP"
 
     def visit_GEOGRAPHY(self, type_, **kw):
@@ -1181,6 +1207,12 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
     def visit_GEOMETRY(self, type_, **kw):
         return "GEOMETRY"
 
+    def visit_DECFLOAT(self, type_, **kw):
+        return "DECFLOAT"
+
+    def visit_VECTOR(self, type_, **kw):
+        return f"VECTOR({type_.element_type}, {type_.dimension})"
+
 
 construct_arguments = [(Table, {"clusterby": None})]
 

{snowflake_sqlalchemy-1.8.2 → snowflake_sqlalchemy-1.9.0}/src/snowflake/sqlalchemy/compat.py

@@ -11,7 +11,7 @@ from sqlalchemy import util
 string_types = (str,)
 returns_unicode = util.symbol("RETURNS_UNICODE")
 
-IS_VERSION_20 = tuple(int(v) for v in SA_VERSION.split(".")) >= (2, 0, 0)
+IS_VERSION_20 = tuple(int(v) for v in SA_VERSION.split(".")[:2]) >= (2, 0)
 
 
 def args_reducer(positions_to_drop: tuple):