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

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

@@ -44,3 +44,10 @@ repos:
       - id: flake8
         additional_dependencies:
           - flake8-bugbear
+-   repo: local
+    hooks:
+      - id: requirements-update
+        name: "Update dependencies from pyproject.toml to snyk/requirements.txt"
+        language: system
+        entry: python snyk/update_requirements.py
+        files: ^pyproject.toml$

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

@@ -9,9 +9,22 @@ Source code is also available at:
 
 # Release Notes
 
-- v1.5.3(Unrelased)
+- v1.6.1(July 9, 2024)
 
-  - Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0
+  - 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)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-sqlalchemy
-Version: 1.5.3
+Version: 1.6.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
@@ -36,7 +36,7 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Requires-Dist: snowflake-connector-python<4.0.0
-Requires-Dist: sqlalchemy<2.0.0,>=1.4.19
+Requires-Dist: sqlalchemy>=1.4.19
 Provides-Extra: development
 Requires-Dist: mock; extra == 'development'
 Requires-Dist: numpy; extra == 'development'
@@ -153,6 +153,7 @@ containing special characters need to be URL encoded to be parsed correctly. Thi
 characters could lead to authentication failure.
 
 The encoding for the password can be generated using `urllib.parse`:
+
 ```python
 import urllib.parse
 urllib.parse.quote("kx@% jj5/g")
@@ -163,6 +164,7 @@ urllib.parse.quote("kx@% jj5/g")
 
 To create an engine with the proper encodings, either manually constructing the url string by formatting
 or taking advantage of the `snowflake.sqlalchemy.URL` helper method:
+
 ```python
 import urllib.parse
 from snowflake.sqlalchemy import URL
@@ -243,14 +245,23 @@ engine = create_engine(...)
 engine.execute(<SQL>)
 engine.dispose()
 
-# Do this.
+# Better.
 engine = create_engine(...)
 connection = engine.connect()
 try:
-    connection.execute(<SQL>)
+  connection.execute(text(<SQL>))
 finally:
     connection.close()
     engine.dispose()
+
+# Best
+try:
+    with engine.connext() as connection:
+        connection.execute(text(<SQL>))
+        # or
+        connection.exec_driver_sql(<SQL>)
+finally:
+    engine.dispose()
 ```
 
 ### Auto-increment Behavior
@@ -294,14 +305,14 @@ engine = create_engine(URL(
 
 specific_date = np.datetime64('2016-03-04T12:03:05.123456789Z')
 
-connection = engine.connect()
-connection.execute(
-    "CREATE OR REPLACE TABLE ts_tbl(c1 TIMESTAMP_NTZ)")
-connection.execute(
-    "INSERT INTO ts_tbl(c1) values(%s)", (specific_date,)
-)
-df = pd.read_sql_query("SELECT * FROM ts_tbl", engine)
-assert df.c1.values[0] == specific_date
+with engine.connect() as connection:
+    connection.exec_driver_sql(
+        "CREATE OR REPLACE TABLE ts_tbl(c1 TIMESTAMP_NTZ)")
+    connection.exec_driver_sql(
+        "INSERT INTO ts_tbl(c1) values(%s)", (specific_date,)
+    )
+    df = pd.read_sql_query("SELECT * FROM ts_tbl", connection)
+    assert df.c1.values[0] == specific_date
 ```
 
 The following `NumPy` data types are supported:

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/README.md

@@ -101,6 +101,7 @@ containing special characters need to be URL encoded to be parsed correctly. Thi
 characters could lead to authentication failure.
 
 The encoding for the password can be generated using `urllib.parse`:
+
 ```python
 import urllib.parse
 urllib.parse.quote("kx@% jj5/g")
@@ -111,6 +112,7 @@ urllib.parse.quote("kx@% jj5/g")
 
 To create an engine with the proper encodings, either manually constructing the url string by formatting
 or taking advantage of the `snowflake.sqlalchemy.URL` helper method:
+
 ```python
 import urllib.parse
 from snowflake.sqlalchemy import URL
@@ -191,14 +193,23 @@ engine = create_engine(...)
 engine.execute(<SQL>)
 engine.dispose()
 
-# Do this.
+# Better.
 engine = create_engine(...)
 connection = engine.connect()
 try:
-    connection.execute(<SQL>)
+  connection.execute(text(<SQL>))
 finally:
     connection.close()
     engine.dispose()
+
+# Best
+try:
+    with engine.connext() as connection:
+        connection.execute(text(<SQL>))
+        # or
+        connection.exec_driver_sql(<SQL>)
+finally:
+    engine.dispose()
 ```
 
 ### Auto-increment Behavior
@@ -242,14 +253,14 @@ engine = create_engine(URL(
 
 specific_date = np.datetime64('2016-03-04T12:03:05.123456789Z')
 
-connection = engine.connect()
-connection.execute(
-    "CREATE OR REPLACE TABLE ts_tbl(c1 TIMESTAMP_NTZ)")
-connection.execute(
-    "INSERT INTO ts_tbl(c1) values(%s)", (specific_date,)
-)
-df = pd.read_sql_query("SELECT * FROM ts_tbl", engine)
-assert df.c1.values[0] == specific_date
+with engine.connect() as connection:
+    connection.exec_driver_sql(
+        "CREATE OR REPLACE TABLE ts_tbl(c1 TIMESTAMP_NTZ)")
+    connection.exec_driver_sql(
+        "INSERT INTO ts_tbl(c1) values(%s)", (specific_date,)
+    )
+    df = pd.read_sql_query("SELECT * FROM ts_tbl", connection)
+    assert df.c1.values[0] == specific_date
 ```
 
 The following `NumPy` data types are supported:

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/ci/build.sh

@@ -3,7 +3,7 @@
 # Build snowflake-sqlalchemy
 set -o pipefail
 
-PYTHON="python3.7"
+PYTHON="python3.8"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 DIST_DIR="${SQLALCHEMY_DIR}/dist"
@@ -11,14 +11,16 @@ DIST_DIR="${SQLALCHEMY_DIR}/dist"
 cd "$SQLALCHEMY_DIR"
 # Clean up previously built DIST_DIR
 if [ -d "${DIST_DIR}" ]; then
-    echo "[WARN] ${DIST_DIR} already existing, deleting it..."
-    rm -rf "${DIST_DIR}"
+  echo "[WARN] ${DIST_DIR} already existing, deleting it..."
+  rm -rf "${DIST_DIR}"
 fi
 
 # Constants and setup
+export PATH=$PATH:$HOME/.local/bin
 
 echo "[Info] Building snowflake-sqlalchemy with $PYTHON"
 # Clean up possible build artifacts
 rm -rf build generated_version.py
-${PYTHON} -m pip install --upgrade pip setuptools wheel build
-${PYTHON} -m build --outdir ${DIST_DIR} .
+export UV_NO_CACHE=true
+${PYTHON} -m pip install uv hatch
+${PYTHON} -m hatch build

snowflake_sqlalchemy-1.6.1/ci/test_linux.sh

@@ -0,0 +1,25 @@
+#!/bin/bash -e
+#
+# Test Snowflake SQLAlchemy in Linux
+# NOTES:
+#   - Versions to be tested should be passed in as the first argument, e.g: "3.7 3.8". If omitted 3.7-3.11 will be assumed.
+#   - This script assumes that ../dist/repaired_wheels has the wheel(s) built for all versions to be tested
+#   - 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}"
+THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
+
+# Install one copy of tox
+python3 -m pip install -U tox
+
+# Run tests
+cd $SQLALCHEMY_DIR
+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
+  echo "[Info] Running tox for ${TEST_ENVLIST}"
+  python3 -m tox -e ${TEST_ENVLIST} --installpkg ${SQLALCHEMY_WHL}
+done

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/pyproject.toml

@@ -38,7 +38,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Application Frameworks",
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-dependencies = ["snowflake-connector-python<4.0.0", "SQLAlchemy>=1.4.19,<2.0.0"]
+dependencies = ["SQLAlchemy>=1.4.19", "snowflake-connector-python<4.0.0"]
 
 [tool.hatch.version]
 path = "src/snowflake/sqlalchemy/version.py"
@@ -73,6 +73,13 @@ exclude = ["/.github"]
 packages = ["src/snowflake"]
 
 [tool.hatch.envs.default]
+extra-dependencies = ["SQLAlchemy>=1.4.19,<2.1.0"]
+features = ["development", "pandas"]
+python = "3.8"
+installer = "uv"
+
+[tool.hatch.envs.sa14]
+extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0"]
 features = ["development", "pandas"]
 python = "3.8"
 
@@ -82,10 +89,18 @@ SQLACHEMY_WARN_20 = "1"
 
 [tool.hatch.envs.default.scripts]
 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"
+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-run_v20 = "pytest -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite --run_v20_sqlalchemy"
 gh-cache-sum = "python -VV | sha256sum | cut -d' ' -f1"
+check-import = "python -c 'import snowflake.sqlalchemy; print(snowflake.sqlalchemy.__version__)'"
+
+[[tool.hatch.envs.release.matrix]]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+features = ["development", "pandas"]
+
+[tool.hatch.envs.release.scripts]
+test-dialect = "pytest -ra -vvv --tb=short --ignore=tests/sqlalchemy_test_suite tests/"
+test-compatibility = "pytest -ra -vvv --tb=short tests/sqlalchemy_test_suite tests/"
 
 [tool.ruff]
 line-length = 88

snowflake_sqlalchemy-1.6.1/snyk/requirements.txt

@@ -0,0 +1,2 @@
+SQLAlchemy>=1.4.19
+snowflake-connector-python<4.0.0

snowflake_sqlalchemy-1.6.1/snyk/requiremtnts.txt

@@ -0,0 +1,2 @@
+snowflake-connector-python<4.0.0
+SQLAlchemy>=1.4.19,<2.1.0

snowflake_sqlalchemy-1.6.1/snyk/update_requirements.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+import tomlkit
+
+
+def sync():
+    pyproject = tomlkit.loads(Path("pyproject.toml").read_text())
+    snyk_reqiurements = Path("snyk/requirements.txt")
+    dependencies = pyproject.get("project", {}).get("dependencies", [])
+
+    with snyk_reqiurements.open("w") as fh:
+        fh.write("\n".join(dependencies))
+        fh.write("\n")
+
+
+if __name__ == "__main__":
+    sync()

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/src/snowflake/sqlalchemy/base.py

@@ -13,13 +13,14 @@ 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
+from sqlalchemy.sql import compiler, expression, functions
 from sqlalchemy.sql.base import CompileState
 from sqlalchemy.sql.elements import quoted_name
 from sqlalchemy.sql.selectable import Lateral, SelectState
-from sqlalchemy.util.compat import string_types
 
+from .compat import IS_VERSION_20, args_reducer, string_types
 from .custom_commands import AWSBucket, AzureContainer, ExternalStage
+from .functions import flatten
 from .util import (
     _find_left_clause_to_join_from,
     _set_connection_interpolate_empty_sequences,
@@ -324,17 +325,9 @@ class SnowflakeORMSelectCompileState(context.ORMSelectCompileState):
 
         return left, replace_from_obj_index, use_entity_index
 
+    @args_reducer(positions_to_drop=(6, 7))
     def _join_left_to_right(
-        self,
-        entities_collection,
-        left,
-        right,
-        onclause,
-        prop,
-        create_aliases,
-        aliased_generation,
-        outerjoin,
-        full,
+        self, entities_collection, left, right, onclause, prop, outerjoin, full
     ):
         """given raw "left", "right", "onclause" parameters consumed from
         a particular key within _join(), add a real ORMJoin object to
@@ -364,7 +357,7 @@ class SnowflakeORMSelectCompileState(context.ORMSelectCompileState):
                 use_entity_index,
             ) = self._join_place_explicit_left_side(entities_collection, left)
 
-        if left is right and not create_aliases:
+        if left is right:
             raise sa_exc.InvalidRequestError(
                 "Can't construct a join from %s to %s, they "
                 "are the same entity" % (left, right)
@@ -373,9 +366,15 @@ class SnowflakeORMSelectCompileState(context.ORMSelectCompileState):
         # the right side as given often needs to be adapted.  additionally
         # a lot of things can be wrong with it.  handle all that and
         # get back the new effective "right" side
-        r_info, right, onclause = self._join_check_and_adapt_right_side(
-            left, right, onclause, prop, create_aliases, aliased_generation
-        )
+
+        if IS_VERSION_20:
+            r_info, right, onclause = self._join_check_and_adapt_right_side(
+                left, right, onclause, prop
+            )
+        else:
+            r_info, right, onclause = self._join_check_and_adapt_right_side(
+                left, right, onclause, prop, False, False
+            )
 
         if not r_info.is_selectable:
             extra_criteria = self._get_extra_criteria(r_info)
@@ -966,34 +965,36 @@ class SnowflakeDDLCompiler(compiler.DDLCompiler):
         )
 
     def visit_identity_column(self, identity, **kw):
-        text = " IDENTITY"
+        text = "IDENTITY"
         if identity.start is not None or identity.increment is not None:
             start = 1 if identity.start is None else identity.start
             increment = 1 if identity.increment is None else identity.increment
             text += f"({start},{increment})"
+        if identity.order is not None:
+            order = "ORDER" if identity.order else "NOORDER"
+            text += f" {order}"
         return text
 
     def get_identity_options(self, identity_options):
         text = []
         if identity_options.increment is not None:
-            text.append(f"INCREMENT BY {identity_options.increment:d}")
+            text.append("INCREMENT BY %d" % identity_options.increment)
         if identity_options.start is not None:
-            text.append(f"START WITH {identity_options.start:d}")
+            text.append("START WITH %d" % identity_options.start)
         if identity_options.minvalue is not None:
-            text.append(f"MINVALUE {identity_options.minvalue:d}")
+            text.append("MINVALUE %d" % identity_options.minvalue)
         if identity_options.maxvalue is not None:
-            text.append(f"MAXVALUE {identity_options.maxvalue:d}")
+            text.append("MAXVALUE %d" % identity_options.maxvalue)
         if identity_options.nominvalue is not None:
             text.append("NO MINVALUE")
         if identity_options.nomaxvalue is not None:
             text.append("NO MAXVALUE")
         if identity_options.cache is not None:
-            text.append(f"CACHE {identity_options.cache:d}")
+            text.append("CACHE %d" % identity_options.cache)
         if identity_options.cycle is not None:
             text.append("CYCLE" if identity_options.cycle else "NO CYCLE")
         if identity_options.order is not None:
             text.append("ORDER" if identity_options.order else "NOORDER")
-
         return " ".join(text)
 
 
@@ -1063,3 +1064,5 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
 
 
 construct_arguments = [(Table, {"clusterby": None})]
+
+functions.register_function("flatten", flatten)

snowflake_sqlalchemy-1.6.1/src/snowflake/sqlalchemy/compat.py

@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+from __future__ import annotations
+
+import functools
+from typing import Callable
+
+from sqlalchemy import __version__ as SA_VERSION
+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)
+
+
+def args_reducer(positions_to_drop: tuple):
+    """Removes args at positions provided in tuple positions_to_drop.
+
+    For example tuple (3, 5) will remove items at third and fifth position.
+    Keep in mind that on class methods first postion is cls or self.
+    """
+
+    def fn_wrapper(fn: Callable):
+        @functools.wraps(fn)
+        def wrapper(*args):
+            reduced_args = args
+            if not IS_VERSION_20:
+                reduced_args = tuple(
+                    arg for idx, arg in enumerate(args) if idx not in positions_to_drop
+                )
+            fn(*reduced_args)
+
+        return wrapper
+
+    return fn_wrapper

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/src/snowflake/sqlalchemy/custom_commands.py

@@ -10,7 +10,8 @@ from sqlalchemy.sql.ddl import DDLElement
 from sqlalchemy.sql.dml import UpdateBase
 from sqlalchemy.sql.elements import ClauseElement
 from sqlalchemy.sql.roles import FromClauseRole
-from sqlalchemy.util.compat import string_types
+
+from .compat import string_types
 
 NoneType = type(None)
 

snowflake_sqlalchemy-1.6.1/src/snowflake/sqlalchemy/functions.py

@@ -0,0 +1,16 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+import warnings
+
+from sqlalchemy.sql import functions as sqlfunc
+
+FLATTEN_WARNING = "For backward compatibility params are not rendered."
+
+
+class flatten(sqlfunc.GenericFunction):
+    name = "flatten"
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(FLATTEN_WARNING, DeprecationWarning, stacklevel=2)
+        super().__init__(*args, **kwargs)

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/src/snowflake/sqlalchemy/requirements.py

@@ -289,9 +289,25 @@ class Requirements(SuiteRequirements):
         # Check https://snowflakecomputing.atlassian.net/browse/SNOW-640134 for details on breaking changes discussion.
         return exclusions.closed()
 
+    @property
+    def date_implicit_bound(self):
+        # Supporting this would require behavior breaking change to implicitly convert str to timestamp when binding
+        # parameters in string forms of timestamp values.
+        return exclusions.closed()
+
+    @property
+    def time_implicit_bound(self):
+        # Supporting this would require behavior breaking change to implicitly convert str to timestamp when binding
+        # parameters in string forms of timestamp values.
+        return exclusions.closed()
+
     @property
     def timestamp_microseconds_implicit_bound(self):
         # Supporting this would require behavior breaking change to implicitly convert str to timestamp when binding
         # parameters in string forms of timestamp values.
         # Check https://snowflakecomputing.atlassian.net/browse/SNOW-640134 for details on breaking changes discussion.
         return exclusions.closed()
+
+    @property
+    def array_type(self):
+        return exclusions.closed()

{snowflake_sqlalchemy-1.5.3 → snowflake_sqlalchemy-1.6.1}/src/snowflake/sqlalchemy/snowdialect.py

@@ -5,6 +5,7 @@
 import operator
 from collections import defaultdict
 from functools import reduce
+from typing import Any
 from urllib.parse import unquote_plus
 
 import sqlalchemy.types as sqltypes
@@ -15,7 +16,6 @@ from sqlalchemy.engine import URL, default, reflection
 from sqlalchemy.schema import Table
 from sqlalchemy.sql import text
 from sqlalchemy.sql.elements import quoted_name
-from sqlalchemy.sql.sqltypes import String
 from sqlalchemy.types import (
     BIGINT,
     BINARY,
@@ -40,6 +40,7 @@ from sqlalchemy.types import (
 from snowflake.connector import errors as sf_errors
 from snowflake.connector.connection import DEFAULT_CONFIGURATION
 from snowflake.connector.constants import UTF8
+from snowflake.sqlalchemy.compat import returns_unicode
 
 from .base import (
     SnowflakeCompiler,
@@ -63,7 +64,11 @@ from .custom_types import (
     _CUSTOM_Float,
     _CUSTOM_Time,
 )
-from .util import _update_connection_application_name, parse_url_boolean
+from .util import (
+    _update_connection_application_name,
+    parse_url_boolean,
+    parse_url_integer,
+)
 
 colspecs = {
     Date: _CUSTOM_Date,
@@ -134,7 +139,7 @@ class SnowflakeDialect(default.DefaultDialect):
     #  unicode strings
     supports_unicode_statements = True
     supports_unicode_binds = True
-    returns_unicode_strings = String.RETURNS_UNICODE
+    returns_unicode_strings = returns_unicode
     description_encoding = None
 
     # No lastrowid support. See SNOW-11155
@@ -195,10 +200,34 @@ class SnowflakeDialect(default.DefaultDialect):
 
     @classmethod
     def dbapi(cls):
+        return cls.import_dbapi()
+
+    @classmethod
+    def import_dbapi(cls):
         from snowflake import connector
 
         return connector
 
+    @staticmethod
+    def parse_query_param_type(name: str, value: Any) -> Any:
+        """Cast param value if possible to type defined in connector-python."""
+        if not (maybe_type_configuration := DEFAULT_CONFIGURATION.get(name)):
+            return value
+
+        _, expected_type = maybe_type_configuration
+        if not isinstance(expected_type, tuple):
+            expected_type = (expected_type,)
+
+        if isinstance(value, expected_type):
+            return value
+
+        elif bool in expected_type:
+            return parse_url_boolean(value)
+        elif int in expected_type:
+            return parse_url_integer(value)
+        else:
+            return value
+
     def create_connect_args(self, url: URL):
         opts = url.translate_connect_args(username="user")
         if "database" in opts:
@@ -235,47 +264,25 @@ class SnowflakeDialect(default.DefaultDialect):
 
         # URL sets the query parameter values as strings, we need to cast to expected types when necessary
         for name, value in query.items():
-            maybe_type_configuration = DEFAULT_CONFIGURATION.get(name)
-            if (
-                not maybe_type_configuration
-            ):  # if the parameter is not found in the type mapping, pass it through as a string
-                opts[name] = value
-                continue
-
-            (_, expected_type) = maybe_type_configuration
-            if not isinstance(expected_type, tuple):
-                expected_type = (expected_type,)
-
-            if isinstance(
-                value, expected_type
-            ):  # if the expected type is str, pass it through as a string
-                opts[name] = value
-
-            elif (
-                bool in expected_type
-            ):  # if the expected type is bool, parse it and pass as a boolean
-                opts[name] = parse_url_boolean(value)
-            else:
-                # TODO: other types like int are stil passed through as string
-                # https://github.com/snowflakedb/snowflake-sqlalchemy/issues/447
-                opts[name] = value
+            opts[name] = self.parse_query_param_type(name, value)
 
         return ([], opts)
 
-    def has_table(self, connection, table_name, schema=None):
+    @reflection.cache
+    def has_table(self, connection, table_name, schema=None, **kw):
         """
         Checks if the table exists
         """
         return self._has_object(connection, "TABLE", table_name, schema)
 
-    def has_sequence(self, connection, sequence_name, schema=None):
+    @reflection.cache
+    def has_sequence(self, connection, sequence_name, schema=None, **kw):
         """
         Checks if the sequence exists
         """
         return self._has_object(connection, "SEQUENCE", sequence_name, schema)
 
     def _has_object(self, connection, object_type, object_name, schema=None):
-
         full_name = self._denormalize_quote_join(schema, object_name)
         try:
             results = connection.execute(