github snowflakedb/snowflake-sqlalchemy v2.0.0rc1
Release
on GitHub

3 hours ago

  • v2.0.0rc1 (Sep 14, 2026)

  • Async support: the dialect now implements SQLAlchemy's asyncio extension. Use create_async_engine() with the same snowflake:// URL as the sync dialect — there is no separate +driver suffix — to obtain AsyncEngine / AsyncSession for non-blocking database access.

  • Breaking change: require snowflake-connector-python>=5.0 (connector 5.x), which is what provides the async driver. Connector 4.x is no longer supported.

  • Breaking change: raise the minimum supported Python to 3.11 (drop Python 3.10), since snowflake-connector-python>=5.0.0rc3 itself requires Python 3.11+ (dropped 3.10). Updates requires-python, Python classifiers, and mypy/ruff targets accordingly.

  • The dialect now sets enable_server_session_keep_alive_auto_detection=True explicitly on new connections. This pins the connector's present default so behaviour stays stable when that default changes, and silences the connector's FutureWarning. A value supplied via the URL or connect_args still takes precedence.

  • Remove the force_div_is_floordiv dialect flag entirely. The / operator always performs true division (left / right) and // always performs floor division (FLOOR(left / right)); the flag had no SQL effect. Passing it to create_engine() now raises ArgumentError (GH #756).

  • v2.0.0a2 (Aug 20, 2026)

    • Breaking change: raise the minimum supported Python to 3.10 (drop Python 3.9). Updates requires-python, the CI/build matrices, and mypy/ruff targets accordingly.
    • enable_structured_type_json now defaults to True (was False); explicitly setting it to False emits a DeprecationWarning (SNOW-3942921).
    • force_div_is_floordiv now defaults to False (was True); explicitly setting it to True emits a DeprecationWarning (SNOW-3942921).
    • legacy_url_params (and its SNOWFLAKE_SQLALCHEMY_LEGACY_URL_PARAMS environment variable) removed; passing it now raises ArgumentError (SNOW-3942921).
    • Fix hybrid table index reflection: normalize reflected index names so unquoted identifiers round-trip in SQLAlchemy's lowercase convention (quoted/case-sensitive names preserved), preserve the caller's original schema (including None) in get_multi_indexes result keys so indexes attach when reflecting under the default schema, and return [] instead of [''] for empty INCLUDE columns (GH #755, fixes GH #754).
    • Add COLLATE support: expression-level Column.collate('<spec>') and column-type collation (String(collation='<spec>')) now render the collation as a single-quoted Snowflake string literal (e.g. COLLATE 'en-ci') instead of an invalid double-quoted identifier. Enables the SQLAlchemy suite CollateTest (SNOW-629086).
    • Add subscript access for semi-structured columns: col["key"] and col[index] on VARIANT, OBJECT, ARRAY and MAP columns now compile to Snowflake's native bracket accessor (e.g. col['key'], col[0]), including nested chains such as col["a"]["b"]. See Reading keys and elements with subscript access (SNOW-1820647 / GH #546).
    • Add opt-in enable_structured_type_json dialect flag (URL parameter or create_engine(..., enable_structured_type_json=True)). When enabled, for semi-structured (untyped) VARIANT, OBJECT and ARRAY columns: reading deserializes the JSON text Snowflake returns into native Python (dict/list/...), and writing native dict/list values serializes them and wraps them in PARSE_JSON — rendered as INSERT ... SELECT (single row and multi-row UNION ALL) since Snowflake rejects functions in a VALUES clause, and as SET col = PARSE_JSON(...) for UPDATE. Typed/structured columns (OBJECT(...) with fields, ARRAY(<type>), MAP) keep their native connector handling. The engine's json_serializer/json_deserializer are used when provided. Off by default, so existing code that reads raw JSON strings or writes pre-serialized values is unchanged (SNOW-1820647 / GH #107).
    • Treat error code 390195 (authentication token expired, variant) as a session disconnect in is_disconnect, so pool_pre_ping / connection_invalidated recover from it like the other token/session-loss codes (SNOW-3882904 / GH #702).
    • Support asdecimal parameter on _CUSTOM_DECIMAL type to allow opt-in conversion of numeric results to float instead of Decimal; default remains Decimal for backward compatibility (SNOW-728151 / GH #373).
    • Fix PrivateLink/regional account parsing where org-style accounts with dashes (e.g., gnamsrm-vi65876.privatelink) were incorrectly truncated at the dash, breaking JWT/key-pair authentication. Account derivation now delegates to the Snowflake Connector's own parse_account, so all host notations (plain, regional, regional/regionless PrivateLink, and .global) match the driver (SNOW-730644, also fixes SNOW-1209099).
    • Add support for Snowflake's multi-table INSERT ALL / INSERT FIRST statements via the new InsertMulti custom command, including conditional (when/else_), OVERWRITE, and per-target column/value mapping (SNOW-782235 / GH #403).
    • Add support for row access policies on SnowflakeTable via the row_access_policy parameter; the policy name accepts a string (optionally fully qualified, e.g. 'db.schema.policy') or a snowflake.sqlalchemy.FQN. See Row Access Policy Support (SNOW-884382 / GH #432).
    • Fix reflection failing on schemas/databases with more than 10,000 objects by paginating the underlying object-listing SHOW commands (get_table_names, get_view_names, get_temp_table_names, get_schema_names, get_sequence_names) with LIMIT ... FROM ... (SNOW-796954 / GH #406).
    • Add opt-in snowflake_rely=True to render RELY on PRIMARY KEY / FOREIGN KEY / UNIQUE constraints so the optimizer can trust them for query rewrites such as join elimination (SNOW-1023317 / GH #463).
    • Add a python_type property to Snowflake custom types (VARIANT, OBJECT, MAP, ARRAY, VECTOR, TIMESTAMP_*, GEOGRAPHY, GEOMETRY, DECFLOAT) for SQLAlchemy compatibility (SNOW-1866493 / GH #562).
    • Fix URL failing to encode [, ], ? and # in passwords, which produced connect strings that could not be parsed (SNOW-828206 / GH #415).
    • Enhance JSONFormatter with the full Snowflake TYPE=JSON option set (date_format, time_format, timestamp_format, binary_format, trim_space, null_if, enable_octal, allow_duplicate, strip_outer_array, strip_null_values, replace_invalid_characters, ignore_utf8_errors, skip_byte_order_mark) (SNOW-589946).
    • Support json_serializer and json_deserializer parameters in create_engine, matching the built-in SQLAlchemy dialects (SNOW-889293 / GH #433).
    • Detect expired-session/token and closed-connection errors as disconnects so connection_invalidated is set and pooled connections are recycled (SNOW-669163 / GH #348).
    • Add if_not_exists and comment options to CreateFileFormat for closer parity with Snowflake's CREATE FILE FORMAT (SNOW-589962 / GH #291).
    • Document SSO/Okta authentication via the authenticator connect_args parameter (SNOW-715550).
    • Document how to enable connector bulk array binding for large executemany inserts via qmark paramstyle (SNOW-710474).
    • Document using a SQLAlchemy VALUES source with MergeInto (no staging table needed) (SNOW-889678 / GH #435).
    • Document writing dicts/lists to VARIANT/OBJECT/ARRAY via INSERT ... SELECT with PARSE_JSON (SNOW-801402 / GH #411).
    • Document the raw-connector workaround for PUT with an in-memory file_stream (BytesIO) (SNOW-645168 / #337).
    • Document CLUSTER BY usage in ORM/declarative models via SnowflakeTable (SNOW-638838 / #313).
    • Document AUTOINCREMENT and IDENTITY column usage, including Sequence vs Identity trade-offs for Hybrid tables (SNOW-1232362).
    • Document that Snowflake lacks IS TRUE/IS FALSE; use col == true()/col == false() (#680).
    • Fix invalid LIMIT -1 SQL generated for a SELECT with OFFSET but no LIMIT; the SnowflakeCompiler now emits LIMIT NULL OFFSET ... as Snowflake requires (NO-SNOW / GH #745).

  • v2.0.0a2 (Unreleased)

  • v2.0.0a0 (July 16, 2026)

    • Breaking change: drop SQLAlchemy 1.4 support. The dialect now requires SQLAlchemy>=2.0.0. Users still on SQLAlchemy 1.4 should pin to snowflake-sqlalchemy<2.0.0.
    • Breaking change: update supported Python versions to >=3.9, <=3.14.
    • Fix regexp_match and regexp_replace flags rendered as bound parameters instead of literal strings (#SNOW-3573046). Flags passed to ColumnElement.regexp_match(..., flags=...) and ColumnElement.regexp_replace(..., flags=...) were processed through the standard parameter pipeline, producing incorrect SQL. Flags are now rendered as inline string literals, matching Snowflake's expected REGEXP_LIKE(col, pattern, 'i') / REGEXP_REPLACE(col, pattern, replacement, 'i') syntax.
    • Add stale workflow for monitoring, commenting on, and closing stale PRs and issues. The new workflow will work on the newly created issues and PRs (for some time in dry-run mode; after validating its work it will be enabled), and the old ones will be addressed manually case by case.
    • Add a contributing guide for local development setup, Hatch usage, and running tests.

Release Notes

  • v1.11.0 (July 7, 2026)

  • Sensitive connection parameters: We curated a set of connector kwargs (host, protocol, token_file_path, private_key_file, ocsp_response_cache_filename, connection_diag_log_path, crl_cache_dir, unsafe_file_write, unsafe_skip_file_permissions_check) that can no longer be supplied via the URL query string — pass them via connect_args= in create_engine() instead (applications already doing so are unaffected). If you encounter a possible behavioral change, set SNOWFLAKE_SQLALCHEMY_LEGACY_URL_PARAMS=1 and follow the instructions at Sensitive connection parameters.

  • Improve _url() helper and create_connect_args connection-parameter handling:

    • account and region values are now validated against an allowlist of DNS-safe characters (alphanumeric, -, ., _) before being interpolated into the connection URL, preventing URL-authority corruption from unexpected characters.
    • user values are percent-encoded before being placed in the URL userinfo component, preserving the original value delivered to the connector while preventing @, ?, and # from being misinterpreted as URL delimiters.

  • ClusterByOption now raises TypeError at DDL compile time when an expression element is neither a str nor a sqlalchemy.sql.expression.TextClause. Previously, such values were silently coerced via str(), which produced malformed DDL (e.g. bind-parameter placeholders like :id_1) for any expression beyond a bare column name. The accepted types match the documented constructor signature; code using only str or text(...) is unaffected.

  • Improve identifier quoting and string-literal escaping for caller-supplied values across the DDL compiler so they are rendered consistently with the rest of the dialect. Column keys in MERGE INTO (both the WHEN NOT MATCHED … INSERT list and WHEN MATCHED … SET targets), stage namespaces/names, format_name, and file_format are now routed through the identifier preparer, and a quote=False schema or column label is quoted when it contains characters that would otherwise require quoting instead of being emitted verbatim. Cloud-storage URIs, CREDENTIALS, and ENCRYPTION clauses (shared by COPY INTO and CREATE STAGE) and FILES=(…) entries now apply the dialect's standard literal escaping ('→'', \→\\); CREATE STAGE builds its SQL from the container's fields rather than repr(container). Legal identifiers — including upper-case names that Snowflake folds — still render bare, so existing DDL is unchanged.

  • Improve escaping in CopyIntoStorage / CreateStage / CreateFileFormat and add secret redaction (SNOW-3656048):

    • FILE_FORMAT option string values (e.g. CSVFormatter().date_format(...), file_extension, timestamp_format) are now escaped before being embedded in the compiled SQL, improving single-quote escaping (SNOW-3649888).
    • repr() of AWSBucket, AzureContainer, GCSBucket (and, transitively, CopyIntoStorage) now masks cloud secrets — AWS_SECRET_KEY, AWS_KEY_ID, AWS_TOKEN, AZURE_SAS_TOKEN, MASTER_KEY are rendered as '***' (SNOW-3649782). Compiled SQL is unchanged.
    • Added an opt-in logging redactor for engine logs that contain inline credentials: SnowflakeSecretRedactionFilter, add_secret_redaction_filter(), and redact_secrets(). Prefer STORAGE_INTEGRATION to avoid putting secrets in SQL at all (SNOW-3649850).

  • Fix get_view_definition silently truncating or failing for view names that contain a single quote or backslash (e.g. o'brien). The name is now SQL-escaped (' → '', \ → \\) before being embedded in the SHOW VIEWS LIKE '...' literal, so such views are found correctly and no query manipulation is possible via a crafted view name.

  • Optimise single-table reflection (SNOW-3720548): reflecting one table no longer scans the entire schema, reducing latency and Snowflake credit usage for targeted Inspector calls.

  • v1.10.2 (June 18, 2026)

  • Fix double-escaped identifier quoting for database-qualified schemas in _StructuredTypeInfoManager.get_table_columns. Since v1.10.1 the schema was quoted as a single identifier, so a qualified schema such as "MYDB"."MYSCHEMA" became """MYDB"".""MYSCHEMA""" and the DESC TABLE fallback failed (emitting a Failed to reflect table ... sqlalchemy:_get_schema_columns warning) for every structured-typed table when reflecting a non-default database.schema. The schema is now split on the dot and each component is double-quoted individually, preserving the SNOW-3480955 injection guard while correctly handling qualified schemas.

  • v1.10.1 (June 15, 2026)

    • Fix regexp_match and regexp_replace flags rendered as bound parameters instead of literal strings (#SNOW-3573046). Flags passed to ColumnElement.regexp_match(..., flags=...) and ColumnElement.regexp_replace(..., flags=...) were processed through the standard parameter pipeline, producing incorrect SQL. Flags are now rendered as inline string literals, matching Snowflake's expected REGEXP_LIKE(col, pattern, 'i') / REGEXP_REPLACE(col, pattern, replacement, 'i') syntax.
    • Fix inconsistent identifier quoting in _StructuredTypeInfoManager.get_table_columns. The DESC TABLE fallback path used raw denormalised names in an f-string while all other reflection paths apply ip.quote(denormalize_name(...)) via _always_quote_join. Schema and table components are now consistently double-quoted before the statement is constructed, and the method delegates to get_table_columns_by_full_name to collapse the two previously divergent code paths.

  • v1.10.0 (May 20, 2026)

    • Fix with_loader_criteria silently dropping filters on non-Snowflake dialects (#676). Importing snowflake-sqlalchemy previously altered SQLAlchemy's ORM compilation for every dialect in the process, causing loader-criteria filters to be omitted inside sealed subqueries when using PostgreSQL, MySQL, SQLite, etc. Snowflake dialect behavior is unchanged; the BCR-1057 lateral-join workaround is now scoped to Snowflake connections only.
    • Map Snowflake UUID column type to sqlalchemy.sql.sqltypes.UUID for reflection on SQLAlchemy 2.x (#681). Previously reflected as NullType. Values are returned as plain strings (as_uuid=False) rather than uuid.UUID instances. No change on SQLAlchemy 1.4 where the generic UUID type does not exist.
    • Add GCS bucket support for CopyIntoStorage (SNOW-721174, #368).
    • Scope referred_schema=None normalization in foreign key reflection to the default schema only (#610, SNOW-2313675):
      • When reflecting the default schema, same-schema FKs (default → default) keep the established SQLAlchemy convention of referred_schema=None, preserving compatibility with the upstream reflection test suite and with applications that do not qualify default-schema FK targets.
      • When reflecting a non-default schema every FK keeps its actual referred_schema, which prevents SQLAlchemy's _reflect_fk from autoloading a non-default-schema target from the wrong place (the bug behind #610) and avoids the Alembic autogenerate mismatch that previously occurred when user metadata explicitly qualified a cross-schema FK that happened to target the default schema.
    • Add SnowflakeBase, snowflake_declarative_base(), and SnowflakeSession to enable efficient bulk inserts for ORM models with nullable optional columns (SNOW-893080, #441). When session.bulk_save_objects() is used with models that have randomly populated nullable columns, SQLAlchemy normally groups objects by their set of non-None column keys, producing O(N) separate INSERT statements. SnowflakeBase / snowflake_declarative_base() pre-populate all plain-nullable columns at construction time, and SnowflakeSession passes render_nulls=True so all objects share the same parameter-key set and are batched into a single executemany INSERT.
    • Fix case-sensitive identifier handling (SNOW-1232488). Always-active bug fixes with no behavioural change for default users:
      • _split_schema_by_dot now correctly parses SQL-escaped double-quotes ("") inside quoted schema/database identifiers (e.g. "my""schema" → my"schema), preventing silent truncation of identifiers containing literal quote characters.
      • denormalize_column_name now correctly double-quotes quoted_name("mycol", True) columns in CLUSTER BY clauses instead of silently dropping the case-sensitivity signal. The caller has already opted into case-sensitive semantics by constructing a quoted_name(..., True), so this is honoured independently of the dialect flag.
      • _has_object (used by has_table / has_sequence) now applies denormalize_name to both the schema and object name before building the DESC SQL, making it consistent with all other reflection methods.
      • Atomic _NameUtils swap in create_connect_args — when the URL's case_sensitive_identifiers value differs from the current dialect state, the name_utils instance is replaced rather than mutated in place, so concurrent readers on other threads observe either the old or the new instance but never a torn update.
    • Add case_sensitive_identifiers opt-in engine flag (kwarg or ?case_sensitive_identifiers=True URL param) governing three related behaviours. The default is False; existing applications are unaffected unless they explicitly opt in:
      • ALL-UPPERCASE reserved-word identifiers (e.g. TABLE) are normalised to quoted_name("table", True) instead of returning unchanged, preventing key-lookup mismatches between creation and reflection.
      • Mixed-case reflected identifiers (e.g. MyCol from a quoted Snowflake column) are returned as quoted_name("MyCol", True) instead of a plain str. Emitted SQL is identical in both modes (_requires_quotes force-quotes any name containing uppercase chars); the difference is only observable via isinstance(..., quoted_name) and .quote.
      • Schema strings with inner double-quotes — e.g. '"myschema"' or '"mydb"."myschema"' — have their extracted parts marked quote=True by _split_schema_by_dot, preserving case-sensitivity in emitted SQL. Without the flag, the extracted parts keep quote=None and the preparer's _requires_quotes heuristic decides per-part (stripping inner quotes for all-lowercase parts, which matches pre-PR behaviour). Use quoted_name("myschema", True) or MetaData(schema=quoted_name(..., True)) to opt into case-sensitivity on a per-value basis without enabling the flag.
    • Add create_snowflake_engine(url, schema=..., case_sensitive_schema=True) helper that URL-encodes case-sensitive schema names using %22 so the Snowflake connector receives the literal double-quoted form. Fix security vulnerability: schema names are now always URL-encoded regardless of case_sensitive_schema, preventing special characters (?, #, /) from being misinterpreted as URL delimiters by SQLAlchemy's URL parser.
    • Add snowflake.sqlalchemy.alembic_util.render_item — a drop-in Alembic render_item hook for env.py that serialises quoted_name columns with quote=True correctly in generated migration files, preventing Alembic autogenerate from silently converting case-sensitive column names to uppercase.
    • Emit SnowflakeWarning at DDL compile time when Identity() is used on a primary key column, alerting users that ORM flush operations will raise a FlushError. The warning is emitted once per unique (table, column) pair per Python process. Use Sequence() instead.
    • Add support for cross-database schema reflection using schema='database.schema' notation. This allows reflecting and joining tables from different databases in a single session without raw SQL. (#456)
    • Restored backward-compatible SQL generation for true division (/) when div_is_floordiv=True: the Snowflake compiler now correctly delegates to the SQLAlchemy base implementation, emitting CAST(col AS NUMERIC) for integer operands as it did before #545 introduced the override (#618).
    • Introduce composite key ordering, fixes #450
    • Optimise reflection performance (SNOW-689531, #656):
      • Add get_multi_columns, get_multi_pk_constraint, get_multi_unique_constraints, get_multi_foreign_keys for SQLAlchemy 2.x bulk reflection — each issues one schema-wide query per reflection pass instead of one query per table.
      • SQLAlchemy 2.x get_columns now uses DESC TABLE directly (per-table, live) since get_multi_columns handles all bulk reflection; temporary tables and dynamic tables are reflected correctly without schema-wide queries.
      • Fix SHOW INDEXES IN TABLE replacing the previous SHOW TABLES LIKE approach for single-table index reflection, eliminating SQL LIKE wildcard false-positives and case-sensitivity bugs.
      • Add _always_quote_join helper that always quotes denormalised identifiers — ensures correct SQL for case-sensitive table and schema names in per-table reflection paths.
      • Fix foreign key referred_schema resolution so reflected FKs always keep their actual schema unless the target lives in the connection's default schema. Previously FKs whose target shared the reflected non-default schema were reported with referred_schema=None, which caused SQLAlchemy's _reflect_fk to autoload from the wrong schema and raise NoReferencedColumnError during Alembic autogenerate.
      • Add shared row-parsing helpers (_parse_pk_rows, _parse_uk_rows, _parse_fk_rows) so correctness fixes propagate to both per-table and schema-wide reflection paths.
      • cache_column_metadata=True opt-in enables per-table SHOW … IN TABLE queries for get_pk_constraint, get_unique_constraints, get_foreign_keys, and get_indexes on SQLAlchemy 1.4.
      • On SQLAlchemy 2.x, get_pk_constraint, get_unique_constraints, get_foreign_keys, and get_indexes now automatically use per-table SHOW … IN TABLE queries without any opt-in flag. Previously these methods always issued SHOW … IN SCHEMA even for single-table Inspector calls (e.g. pandas.read_sql_table()), causing ~20-second delays on schemas with thousands of tables (SNOW-689531).

  • 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).
      • Fix crash when SHOW TABLES returns empty string table names, causing IndexError during reflection (#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), references: #644
    • Support timezone in timestamp and datetime types (#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

  • v1.8.1 (December 9, 2025)

    • Add python 3.14 to project metadata

  • v1.8.0(December 5, 2025)

    • Add logging of SQLAlchemy version
    • Bump snowflake-connector-python<5.0.0
    • Add python up to 3.14
    • Add logging of SQLAlchemy version and pandas (if used)

  • v1.7.7(September 3, 2025)

    • Fix exception for structured type columns dropped while collecting metadata

  • v1.7.6(July 10, 2025)

    • Fix get_multi_indexes issue, wrong assign of returned indexes when processing multiple indexes in a table

  • v1.7.5(June 20, 2025)

    • Fix compilation of Merge and Copy Into was not working

  • 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
    • Fix index columns was not being reflected
    • Fix index reflection cache not working
    • Add support for structured OBJECT datatype
    • Add support for structured ARRAY datatype

  • v1.7.1(December 02, 2024)

    • Add support for partition by to copy into
    • Fix BOOLEAN type not found in snowdialect
    • Add support for autocommit Isolation Level

  • 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

  • v1.6.0(July 8, 2024)

    • support for installing with SQLAlchemy 2.0.x
    • use hatch & uv for managing project virtual environments

  • v1.5.4

    • Add ability to set ORDER / NOORDER sequence on columns with IDENTITY

  • v1.5.3(April 16, 2024)

    • Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0

  • v1.5.2(April 11, 2024)

    • Bump min SQLAlchemy to 1.4.19 for outer lateral join
    • Add support for sequence ordering in tests

  • 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 credentials with externalbrowser authentication not caching due to incorrect parsing of boolean query parameters.
      • This fixes other boolean parameter passing to driver as well.

  • v1.5.0(Aug 23, 2023)

    • Added option to create a temporary stage command.
    • Added support for geometry type.
    • Fixed a compatibility issue of regex expression with SQLAlchemy 1.4.49.

  • v1.4.7(Mar 22, 2023)

    • Re-applied the application name of driver connection SnowflakeConnection to SnowflakeSQLAlchemy.
    • SnowflakeDialect.get_columns now throws a NoSuchTableError exception when the specified table doesn't exist, instead of the more vague KeyError.
    • Fixed a bug that dialect can not be created with empty host name.
    • Fixed a bug that sqlalchemy.func.now is not rendered correctly.

  • v1.4.6(Feb 8, 2023)

    • Bumped snowflake-connector-python dependency to newest version which supports Python 3.11.
    • Reverted the change of application name introduced in v1.4.5 until support gets added.

  • v1.4.5(Dec 7, 2022)

    • Updated the application name of driver connection SnowflakeConnection to SnowflakeSQLAlchemy.

  • v1.4.4(Nov 16, 2022)

    • Fixed a bug that percent signs in a non-compiled statement should not be interpolated with emtpy sequence when executed.

  • v1.4.3(Oct 17, 2022)

    • Fixed a bug that SnowflakeDialect.normalize_name and SnowflakeDialect.denormalize_name could not handle empty string.
    • Fixed a compatibility issue to vendor function sqlalchemy.engine.url._rfc_1738_quote as it is removed from SQLAlchemy v1.4.42.

  • v1.4.2(Sep 19, 2022)

    • Improved performance by standardizing string interpolations to f-strings.
    • Improved reliability by always using context managers.

  • v1.4.1(Aug 18, 2022)

    • snowflake-sqlalchemy is now SQLAlchemy 2.0 compatible.
    • Fixed a bug that DATE should not be removed from SnowflakeDialect.ischema_names.
    • Fixed breaking changes introduced in release 1.4.0 that:
      • changed the behavior of processing numeric, datetime and timestamp values returned from service.
      • changed the sequence order of primary/foreign keys in list returned by inspect.get_foreign_keys and inspect.get_pk_constraint.

  • v1.4.0(July 20, 2022)

    • Added support for regexp_match, regexp_replace in sqlalchemy.sql.expression.ColumnOperators.
    • Added support for Identity Column.
    • Added support for handling literals value of sql type Date, DateTime, Time, Float and Numeric, and converting the values into corresponding Python objects.
    • Added support for get_sequence_names in SnowflakeDialect.
    • Fixed a bug where insert with autoincrement failed due to incompatible column type affinity #124.
    • Fixed a bug when creating a column with sequence, default value was set incorrectly.
    • Fixed a bug that identifier having percents in a compiled statement was not interpolated.
    • Fixed a bug when visiting sequence value from another schema, the sequence name is not formatted with the schema name.
    • Fixed a bug where the sequence order of columns were not maintained when retrieving primary keys and foreign keys for a table.

  • v1.3.4(April 27,2022)

    • Fixed a bug where identifier max length was set to the wrong value and added relevant schema introspection
    • Add support for geography type
    • Fixed a bug where foreign key's referred schema was set incorrectly
    • Disabled new SQLAlchemy option for statement caching until support gets added

  • v1.3.3(December 19,2021)

    • Fixed an issue where quote arguments were stripped from identifiers.

  • v1.3.2 (September 14,2021)

    • Fixed a breaking change introduced in SQLAlchemy 1.4 that changed the behavior of returns_unicode_strings.

  • v1.3.1 (July 23,2021)

    • Raising minimum version of SQLAlchemy to match used features.

  • v1.2.5 (July 20,2021)

    • Various custom command bug fixes and additions.

  • v1.2.4 (October 05,2020)

    • Fixed an issue where inspector would not properly switch to table wide column retrieving when schema wide column retrieving was taking too long to respond.

  • v1.2.3 (March 30, 2020)

    • Update tox.ini
    • Add external stage to COPY INTO custom command.
    • Bumped pandas to newest versions

  • v1.2.2 (March 9, 2020)

    • Allow get_table_comment to fetch view comments too

  • v1.2.1 (February 18,2020)

    • Add driver property to SnowflakeDialect #140
    • Suppress deprecation warning by fixing import

  • v1.2.0 (January 27, 2020)

    • Fix typo in README Connection Parameters #141
    • Fix sqlalchemy and possibly python-connector warnings
    • Fix handling of empty table comments #137
    • Fix handling spaces in connection string passwords #149

  • v1.1.18 (January 6,2020)

    • Set current schema in connection string containing special characters
    • Calling str on custom_types throws Exception

  • v1.1.17 (December 2,2019)

    • Comments not created when creating new table #118
    • SQLAlchemy Column Metadata Cache not working
    • Timestamp DDL renders wrong when precision value passed
    • Fixed special character handling in snowflake-sqlalchemy from URL string
    • Added development optional dependencies to Python packages

  • v1.1.16 (October 21,2019)

    • Fix SQLAlchemy not working with global url

  • v1.1.15 (September 30, 2019)

    • Incorrect SQL generated for INSERT with CTE
    • Type Synonyms not exported to top-level module #109

  • v1.1.14 (August 12, 2019)

    • Fix CSVFormatter class has FIELD_DELIMETER spelled incorrectly

  • v1.1.13 (May 20,2019)

    • CopyInto's maxfilesize method expects a bool instead of an int
    • CopyInto statement doesn't compile correctly when the source is storage and the destination is a table

  • v1.1.12 (April 8,2019)

    • Add ability to inspect column comments
    • Restricting index creation checking to only SnowflakeDialect tables

  • v1.1.11 (March 25, 2019)

    • Remove relative reference to connector from SQLAlchemy dialect

  • v1.1.10 (February 22, 2019)

    • Separated base.py file into smaller files and fixed import statements
    • Prevent creating tables with indexes in SQLAlchemy
    • Add tox support

  • v1.1.9 (February 11, 2019)

    • Fix an issue in v1.1.8

  • v1.1.8 (February 8, 2019)

    • Fixed a dependency

  • v1.1.7 (February 8, 2019)

    • Added Upsert in sql-alchemy
    • CopyIntoS3 command in SQLAlchemy

  • v1.1.6 (January 3, 2019)

    • Fixed 'module' object is not callable in csvsql

  • v1.1.5 (December 19, 2018)

    • Added multivalue_support feature flag
    • Deprecate get_primary_keys

  • v1.1.4 (November 13, 2018)

    • Fixed lable/alias by honoring quote_name.

  • v1.1.3 (October 30, 2018)

    • SQLAlchemy 1.2 multi table support.
    • TIMESTAMP_LTZ, TIMESTAMP_NTZ and TIMESTAMP_TZ support.
    • Fixed relative import issue in SQLAlchemy

  • v1.1.2 (June 7, 2018)

    • Removes username restriction for OAuth

  • v1.1.1 (May 17, 2018)

    • Made password as optional parameter for SSO support
    • Fixed paramstyl=qmark mode where the data are bound in the server instead of client side
    • Fixed multipart schema support. Now db.schema can be specified in the schema parameters.
    • Added region parameter support to URL utility method.

  • v1.1.0 (February 1, 2018)

    • Updated doc including role example.
    • Fixed the return value of get_pk_constraint and get_primary_keys. Those applications that depend on the old behaviors must update codes. Issue #38 (@nrth)
    • Updated doc including a note about open and close connections.

  • v1.0.9 (January 4, 2018)

    • Fixed foreign key names that should be normalized. Issue #24 (@cladden)
    • Set the default schema Issue #25 (@cladden)
    • Improved performance by caching current database and schema for inspector. Issue #30 (@cladden)

  • v1.0.8 (December 21, 2017)

    • Added get_schema_names method to Snowflake SQLAlchemy dialect. PR #20(andrewsali)
    • Fixed the column metadata including length for string/varchar and precision and scale for numeric data type. Issue #22(@cladden)

  • v1.0.7 (May 18, 2017)

    • Fixed COPY command transaction issue. PR #16(Pangstar) and Issue #17(Pangstar)

  • v1.0.6 (April 20, 2017)

    • Fixed account with subdomain issue. Issue #15(Pangstar)

  • v1.0.5 (April 13, 2017)

    • Added snowflake_clusterby option support to Table object so that the user can create a table with clustering keys

  • v1.0.4 (March 9, 2017)

    • Added SQLAlchemy 1.1 support

  • v1.0.3 (October 20, 2016)

    • Added VARIANT, OBJECT and ARRAY data type supports for fetch

  • v1.0.2 (July 5, 2016)

    • Fixed the development status in classifiers. 5 - Production/Stable

  • v1.0.1 (July 4, 2016)

    • Fixed URL method in case of including warehouse without database.

  • v1.0.0 (June 28, 2016)

    • General Availability
Check out latest releases or
releases around snowflakedb/snowflake-sqlalchemy v2.0.0rc1

Don't miss a new snowflake-sqlalchemy release

NewReleases is sending notifications on new releases.

Get notifications