snowflake-sqlalchemy 1.7.6__tar.gz → 1.8.0__tar.gz

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/DESCRIPTION.md

@@ -6,9 +6,20 @@ Snowflake Documentation is available at:
 
 Source code is also available at:
 <https://github.com/snowflakedb/snowflake-sqlalchemy>
+
 # Unreleased Notes
 
 # Release Notes
+
+- 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
 

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.7.6
+Version: 1.8.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
@@ -27,6 +27,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
@@ -35,7 +36,7 @@ Classifier: Topic :: Software Development :: Libraries
 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: snowflake-connector-python<5.0.0
 Requires-Dist: sqlalchemy>=1.4.19
 Provides-Extra: development
 Requires-Dist: mock; extra == 'development'
@@ -63,9 +64,6 @@ 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: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
-|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-
 
 ## Prerequisites
 

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/README.md

@@ -9,9 +9,6 @@
 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: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
-|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-
 
 ## Prerequisites
 

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/ci/docker/sqlalchemy_build/Dockerfile

@@ -4,9 +4,9 @@ FROM $BASE_IMAGE
 
 # This is to solve permission issue, read https://denibertovic.com/posts/handling-permissions-with-docker-volumes/
 ARG GOSU_URL=https://github.com/tianon/gosu/releases/download/1.14/gosu-amd64
-ENV GOSU_PATH $GOSU_URL
+ENV GOSU_PATH=$GOSU_URL
 RUN curl -o /usr/local/bin/gosu -SL $GOSU_PATH \
-    && chmod +x /usr/local/bin/gosu
+  && chmod +x /usr/local/bin/gosu
 
 COPY scripts/entrypoint.sh /usr/local/bin/entrypoint.sh
 RUN chmod +x /usr/local/bin/entrypoint.sh
@@ -14,6 +14,13 @@ RUN chmod +x /usr/local/bin/entrypoint.sh
 WORKDIR /home/user
 RUN chmod 777 /home/user
 
-ENV PATH="${PATH}:/opt/python/cp37-cp37m/bin:/opt/python/cp38-cp38/bin:/opt/python/cp39-cp39/bin:/opt/python/cp310-cp310/bin:/opt/python/cp311-cp311/bin"
+ENV PATH="${PATH}:/opt/python/cp37-cp37/bin"
+ENV PATH="${PATH}:/opt/python/cp38-cp38/bin"
+ENV PATH="${PATH}:/opt/python/cp39-cp39/bin"
+ENV PATH="${PATH}:/opt/python/cp310-cp310/bin"
+ENV PATH="${PATH}:/opt/python/cp311-cp311/bin"
+ENV PATH="${PATH}:/opt/python/cp312-cp312/bin"
+ENV PATH="${PATH}:/opt/python/cp313-cp313/bin"
+ENV PATH="${PATH}:/opt/python/cp314-cp314/bin"
 
 ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/ci/test_docker.sh

@@ -7,11 +7,11 @@
 set -o pipefail
 
 # In case this is ran from dev-vm
-PYTHON_ENV=${1:-3.7}
+PYTHON_ENV=${1:-3.8}
 
 # Set constants
-THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SQLALCHEMY_DIR="$( dirname "${THIS_DIR}")"
+THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 WORKSPACE=${WORKSPACE:-$SQLALCHEMY_DIR}
 source $THIS_DIR/set_base_image.sh
 
@@ -35,19 +35,19 @@ echo "[Info] Start building docker image and testing"
 
 user_id=$(id -u ${USER})
 docker run \
-    --rm \
-    --network=host \
-    -e TERM=vt102 \
-    -e PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    -e OPENSSL_FIPS=1 \
-    -e LOCAL_USER_ID=${user_id} \
-    -e AWS_ACCESS_KEY_ID \
-    -e AWS_SECRET_ACCESS_KEY \
-    -e SF_REGRESS_LOGS \
-    -e SF_PROJECT_ROOT \
-    -e cloud_provider \
-    -e JENKINS_HOME \
-    -e GITHUB_ACTIONS \
-    --mount type=bind,source="${SQLALCHEMY_DIR}",target=/home/user/snowflake-sqlalchemy \
-    $(docker build --pull --build-arg BASE_IMAGE=$BASE_IMAGE --build-arg GOSU_URL="$GOSU_URL" -q .) \
-    /home/user/snowflake-sqlalchemy/ci/test_linux.sh ${PYTHON_ENV}
+  --rm \
+  --network=host \
+  -e TERM=vt102 \
+  -e PIP_DISABLE_PIP_VERSION_CHECK=1 \
+  -e OPENSSL_FIPS=1 \
+  -e LOCAL_USER_ID=${user_id} \
+  -e AWS_ACCESS_KEY_ID \
+  -e AWS_SECRET_ACCESS_KEY \
+  -e SF_REGRESS_LOGS \
+  -e SF_PROJECT_ROOT \
+  -e cloud_provider \
+  -e JENKINS_HOME \
+  -e GITHUB_ACTIONS \
+  --mount type=bind,source="${SQLALCHEMY_DIR}",target=/home/user/snowflake-sqlalchemy \
+  $(docker build --pull --build-arg BASE_IMAGE=$BASE_IMAGE --build-arg GOSU_URL="$GOSU_URL" -q .) \
+  /home/user/snowflake-sqlalchemy/ci/test_linux.sh ${PYTHON_ENV}

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/ci/test_linux.sh

@@ -6,7 +6,7 @@
 #   - 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}"
+PYTHON_VERSIONS="${1:-3.8 3.9 3.10 3.11 3.12 3.13 3.14}"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 
@@ -19,7 +19,7 @@ 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
+  TEST_ENVLIST=fix_lint,py${SHORT_VERSION}-ci,py${SHORT_VERSION}-coverage,py${SHORT_VERSION}-pandas-ci,py${SHORT_VERSION}-pandas-coverage
   echo "[Info] Running tox for ${TEST_ENVLIST}"
   python3 -m tox -e ${TEST_ENVLIST} --installpkg ${SQLALCHEMY_WHL}
 done

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/pyproject.toml

@@ -30,6 +30,7 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Programming Language :: SQL",
   "Topic :: Database",
   "Topic :: Scientific/Engineering :: Information Analysis",
@@ -38,7 +39,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Application Frameworks",
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-dependencies = ["SQLAlchemy>=1.4.19", "snowflake-connector-python<4.0.0"]
+dependencies = ["SQLAlchemy>=1.4.19", "snowflake-connector-python<5.0.0"]
 
 [tool.hatch.version]
 path = "src/snowflake/sqlalchemy/version.py"
@@ -75,17 +76,17 @@ exclude = ["/.github"]
 packages = ["src/snowflake"]
 
 [tool.hatch.envs.default]
-path = ".venv"
-type = "virtual"
 extra-dependencies = ["SQLAlchemy>=1.4.19,<2.1.0"]
 features = ["development", "pandas"]
-python = "3.8"
+python = "3.12"
 installer = "uv"
 
 [tool.hatch.envs.sa14]
-extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0"]
+installer = "uv"
+builder = true
+extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0", "pandas<2.1", "numpy<2"]
 features = ["development", "pandas"]
-python = "3.8"
+python = "3.12"
 
 [tool.hatch.envs.sa14.scripts]
 test-dialect = "pytest --ignore_v20_test -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
@@ -105,7 +106,7 @@ 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"]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
 features = ["development", "pandas"]
 
 [tool.hatch.envs.release.scripts]

snowflake_sqlalchemy-1.8.0/snyk/requirements.txt

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

snowflake_sqlalchemy-1.8.0/src/snowflake/sqlalchemy/name_utils.py

@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+from sqlalchemy.sql.compiler import IdentifierPreparer
+from sqlalchemy.sql.elements import quoted_name
+
+
+class _NameUtils:
+
+    def __init__(self, identifier_preparer: IdentifierPreparer) -> None:
+        self.identifier_preparer = identifier_preparer
+
+    def normalize_name(self, name):
+        if name is None:
+            return None
+        if name == "":
+            return ""
+        if name.upper() == name and not self.identifier_preparer._requires_quotes(
+            name.lower()
+        ):
+            return name.lower()
+        elif name.lower() == name:
+            return quoted_name(name, quote=True)
+        else:
+            return name
+
+    def denormalize_name(self, name):
+        if name is None:
+            return None
+        if name == "":
+            return ""
+        elif name.lower() == name and not self.identifier_preparer._requires_quotes(
+            name.lower()
+        ):
+            name = name.upper()
+        return name

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/src/snowflake/sqlalchemy/parser/custom_type_parser.py

@@ -2,9 +2,8 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 from typing import List
 
-import sqlalchemy.types as sqltypes
-from sqlalchemy.sql.type_api import TypeEngine
-from sqlalchemy.types import (
+import sqlalchemy.sql.sqltypes as sqltypes
+from sqlalchemy.sql.sqltypes import (
     BIGINT,
     BINARY,
     BOOLEAN,
@@ -21,6 +20,7 @@ from sqlalchemy.types import (
     VARCHAR,
     NullType,
 )
+from sqlalchemy.sql.type_api import TypeEngine
 
 from ..custom_types import (
     _CUSTOM_DECIMAL,

{snowflake_sqlalchemy-1.7.6 → snowflake_sqlalchemy-1.8.0}/src/snowflake/sqlalchemy/snowdialect.py

@@ -2,28 +2,33 @@
 # Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
 #
 import operator
-import re
 from collections import defaultdict
 from enum import Enum
 from functools import reduce
-from typing import Any, Collection, Optional
+from logging import getLogger
+from time import time as time_in_seconds
+from typing import Any, Collection, Optional, cast
 from urllib.parse import unquote_plus
 
 import sqlalchemy.sql.sqltypes as sqltypes
+from sqlalchemy import __version__ as SQLALCHEMY_VERSION
 from sqlalchemy import event as sa_vnt
 from sqlalchemy import exc as sa_exc
 from sqlalchemy import util as sa_util
 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 NullType
 from sqlalchemy.types import FLOAT, Date, DateTime, Float, Time
 
 from snowflake.connector import errors as sf_errors
-from snowflake.connector.connection import DEFAULT_CONFIGURATION
+from snowflake.connector.connection import DEFAULT_CONFIGURATION, SnowflakeConnection
 from snowflake.connector.constants import UTF8
+from snowflake.connector.network import SnowflakeRestful
+from snowflake.connector.telemetry import TelemetryClient, TelemetryData, TelemetryField
 from snowflake.sqlalchemy.compat import returns_unicode
+from snowflake.sqlalchemy.name_utils import _NameUtils
+from snowflake.sqlalchemy.structured_type_info_manager import _StructuredTypeInfoManager
 
 from ._constants import DIALECT_NAME
 from .base import (
@@ -42,7 +47,7 @@ from .custom_types import (
 )
 from .parser.custom_type_parser import *  # noqa
 from .parser.custom_type_parser import _CUSTOM_DECIMAL  # noqa
-from .parser.custom_type_parser import ischema_names, parse_index_columns, parse_type
+from .parser.custom_type_parser import ischema_names, parse_index_columns
 from .sql.custom_schema.custom_table_prefix import CustomTablePrefix
 from .util import (
     _update_connection_application_name,
@@ -59,6 +64,12 @@ colspecs = {
 
 _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME = True
 
+logger = getLogger(__name__)
+
+
+class TelemetryEvents(Enum):
+    NEW_CONNECTION = "sqlalchemy_new_connection"
+
 
 class SnowflakeIsolationLevel(Enum):
     READ_COMMITTED = "READ COMMITTED"
@@ -157,6 +168,7 @@ class SnowflakeDialect(default.DefaultDialect):
         super().__init__(isolation_level=isolation_level, **kwargs)
         self.force_div_is_floordiv = force_div_is_floordiv
         self.div_is_floordiv = force_div_is_floordiv
+        self.name_utils = _NameUtils(self.identifier_preparer)
 
     def initialize(self, connection):
         super().initialize(connection)
@@ -282,29 +294,10 @@ class SnowflakeDialect(default.DefaultDialect):
             raise
 
     def normalize_name(self, name):
-        if name is None:
-            return None
-        if name == "":
-            return ""
-        if name.upper() == name and not self.identifier_preparer._requires_quotes(
-            name.lower()
-        ):
-            return name.lower()
-        elif name.lower() == name:
-            return quoted_name(name, quote=True)
-        else:
-            return name
+        return self.name_utils.normalize_name(name)
 
     def denormalize_name(self, name):
-        if name is None:
-            return None
-        if name == "":
-            return ""
-        elif name.lower() == name and not self.identifier_preparer._requires_quotes(
-            name.lower()
-        ):
-            name = name.upper()
-        return name
+        return self.name_utils.denormalize_name(name)
 
     def _denormalize_quote_join(self, *idents):
         ip = self.identifier_preparer
@@ -491,53 +484,31 @@ class SnowflakeDialect(default.DefaultDialect):
         )
         return foreign_key_map.get(table_name, [])
 
-    def table_columns_as_dict(self, columns):
-        result = {}
-        for column in columns:
-            result[column["name"]] = column
-        return result
-
     @reflection.cache
     def _get_schema_columns(self, connection, schema, **kw):
         """Get all columns in the schema, if we hit 'Information schema query returned too much data' problem return
         None, as it is cacheable and is an unexpected return type for this function"""
         ans = {}
-        current_database, _ = self._current_database_schema(connection, **kw)
+
+        schema_name = self.denormalize_name(schema)
+
+        result = self._query_all_columns_info(connection, schema_name, **kw)
+        if result is None:
+            return None
+
+        current_database, default_schema = self._current_database_schema(
+            connection, **kw
+        )
         full_schema_name = self._denormalize_quote_join(current_database, schema)
-        full_columns_descriptions = {}
-        try:
-            schema_primary_keys = self._get_schema_primary_keys(
-                connection, full_schema_name, **kw
-            )
-            schema_name = self.denormalize_name(schema)
 
-            result = connection.execute(
-                text(
-                    """
-            SELECT /* sqlalchemy:_get_schema_columns */
-                   ic.table_name,
-                   ic.column_name,
-                   ic.data_type,
-                   ic.character_maximum_length,
-                   ic.numeric_precision,
-                   ic.numeric_scale,
-                   ic.is_nullable,
-                   ic.column_default,
-                   ic.is_identity,
-                   ic.comment,
-                   ic.identity_start,
-                   ic.identity_increment
-              FROM information_schema.columns ic
-             WHERE ic.table_schema=:table_schema
-             ORDER BY ic.ordinal_position"""
-                ),
-                {"table_schema": schema_name},
-            )
-        except sa_exc.ProgrammingError as pe:
-            if pe.orig.errno == 90030:
-                # This means that there are too many tables in the schema, we need to go more granular
-                return None  # None triggers _get_table_columns while staying cacheable
-            raise
+        schema_primary_keys = self._get_schema_primary_keys(
+            connection, full_schema_name, **kw
+        )
+
+        structured_type_info_manager = _StructuredTypeInfoManager(
+            connection, self.name_utils, default_schema
+        )
+
         for (
             table_name,
             column_name,
@@ -572,25 +543,11 @@ class SnowflakeDialect(default.DefaultDialect):
                 elif issubclass(col_type, (sqltypes.String, sqltypes.BINARY)):
                     col_type_kw["length"] = character_maximum_length
                 elif issubclass(col_type, StructuredType):
-                    if (schema_name, table_name) not in full_columns_descriptions:
-                        full_columns_descriptions[(schema_name, table_name)] = (
-                            self.table_columns_as_dict(
-                                self._get_table_columns(
-                                    connection, table_name, schema_name
-                                )
-                            )
-                        )
-
-                    if (
-                        (schema_name, table_name) in full_columns_descriptions
-                        and column_name
-                        in full_columns_descriptions[(schema_name, table_name)]
-                    ):
-                        ans[table_name].append(
-                            full_columns_descriptions[(schema_name, table_name)][
-                                column_name
-                            ]
-                        )
+                    column_info = structured_type_info_manager.get_column_info(
+                        schema_name, table_name, column_name, **kw
+                    )
+                    if column_info:
+                        ans[table_name].append(column_info)
                         continue
                     else:
                         col_type = NullType
@@ -628,72 +585,6 @@ class SnowflakeDialect(default.DefaultDialect):
                 }
         return ans
 
-    @reflection.cache
-    def _get_table_columns(self, connection, table_name, schema=None, **kw):
-        """Get all columns in a table in a schema"""
-        ans = []
-        current_database, default_schema = self._current_database_schema(
-            connection, **kw
-        )
-        schema = schema if schema else default_schema
-        table_schema = self.denormalize_name(schema)
-        table_name = self.denormalize_name(table_name)
-        result = connection.execute(
-            text(
-                "DESC /* sqlalchemy:_get_schema_columns */"
-                f" TABLE {table_schema}.{table_name} TYPE = COLUMNS"
-            )
-        )
-        for desc_data in result:
-            column_name = desc_data[0]
-            coltype = desc_data[1]
-            is_nullable = desc_data[3]
-            column_default = desc_data[4]
-            primary_key = desc_data[5]
-            comment = desc_data[9]
-
-            column_name = self.normalize_name(column_name)
-            if column_name.startswith("sys_clustering_column"):
-                continue  # ignoring clustering column
-            type_instance = parse_type(coltype)
-            if isinstance(type_instance, NullType):
-                sa_util.warn(
-                    f"Did not recognize type '{coltype}' of column '{column_name}'"
-                )
-
-            identity = None
-            match = re.match(
-                r"IDENTITY START (?P<start>\d+) INCREMENT (?P<increment>\d+) (?P<order_type>ORDER|NOORDER)",
-                column_default if column_default else "",
-            )
-            if match:
-                identity = {
-                    "start": int(match.group("start")),
-                    "increment": int(match.group("increment")),
-                    "order_type": match.group("order_type"),
-                }
-            is_identity = identity is not None
-
-            ans.append(
-                {
-                    "name": column_name,
-                    "type": type_instance,
-                    "nullable": is_nullable == "Y",
-                    "default": None if is_identity else column_default,
-                    "autoincrement": is_identity,
-                    "comment": comment if comment != "" else None,
-                    "primary_key": primary_key == "Y",
-                }
-            )
-
-            if is_identity:
-                ans[-1]["identity"] = identity
-
-        # If we didn't find any columns for the table, the table doesn't exist.
-        if len(ans) == 0:
-            raise sa_exc.NoSuchTableError()
-        return ans
-
     def get_columns(self, connection, table_name, schema=None, **kw):
         """
         Gets all column info given the table info
@@ -704,8 +595,11 @@ class SnowflakeDialect(default.DefaultDialect):
 
         schema_columns = self._get_schema_columns(connection, schema, **kw)
         if schema_columns is None:
+            column_info_manager = _StructuredTypeInfoManager(
+                connection, self.name_utils, self.default_schema_name
+            )
             # Too many results, fall back to only query about single table
-            return self._get_table_columns(connection, table_name, schema, **kw)
+            return column_info_manager.get_table_columns(table_name, schema)
         normalized_table_name = self.normalize_name(table_name)
         if normalized_table_name not in schema_columns:
             raise sa_exc.NoSuchTableError()
@@ -719,6 +613,37 @@ class SnowflakeDialect(default.DefaultDialect):
                 prefixes_found.append(valid_prefix.name)
         return prefixes_found
 
+    @reflection.cache
+    def _query_all_columns_info(self, connection, schema_name, **kw):
+        try:
+            return connection.execute(
+                text(
+                    """
+            SELECT /* sqlalchemy:_get_schema_columns */
+                   ic.table_name,
+                   ic.column_name,
+                   ic.data_type,
+                   ic.character_maximum_length,
+                   ic.numeric_precision,
+                   ic.numeric_scale,
+                   ic.is_nullable,
+                   ic.column_default,
+                   ic.is_identity,
+                   ic.comment,
+                   ic.identity_start,
+                   ic.identity_increment
+              FROM information_schema.columns ic
+             WHERE ic.table_schema=:table_schema
+             ORDER BY ic.ordinal_position"""
+                ),
+                {"table_schema": schema_name},
+            )
+        except sa_exc.ProgrammingError as pe:
+            if pe.orig.errno == 90030:
+                # This means that there are too many tables in the schema, we need to go more granular
+                return None  # None triggers get_table_columns while staying cacheable
+            raise
+
     @reflection.cache
     def _get_schema_tables_info(self, connection, schema=None, **kw):
         """
@@ -982,18 +907,53 @@ class SnowflakeDialect(default.DefaultDialect):
         return self._value_or_default(data, table_name, schema)
 
     def connect(self, *cargs, **cparams):
-        return (
-            super().connect(
-                *cargs,
-                **(
-                    _update_connection_application_name(**cparams)
-                    if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
-                    else cparams
-                ),
+        if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME:
+            cparams = _update_connection_application_name(**cparams)
+
+        connection = super().connect(*cargs, **cparams)
+        self._log_new_connection_event(connection)
+
+        return connection
+
+    def _log_new_connection_event(self, connection):
+        try:
+            snowflake_connection = cast(SnowflakeConnection, cast(object, connection))
+            snowflake_rest_client = SnowflakeRestful(
+                host=snowflake_connection.host,
+                port=snowflake_connection.port,
+                protocol="https",
+                connection=snowflake_connection,
+            )
+            snowflake_telemetry_client = TelemetryClient(rest=snowflake_rest_client)
+
+            telemetry_value = {
+                "SQLAlchemy": SQLALCHEMY_VERSION,
+            }
+            try:
+                from pandas import __version__ as PANDAS_VERSION
+
+                telemetry_value["pandas"] = PANDAS_VERSION
+            except ImportError:
+                pass
+
+            snowflake_telemetry_client.add_log_to_batch(
+                TelemetryData.from_telemetry_data_dict(
+                    from_dict={
+                        TelemetryField.KEY_TYPE.value: TelemetryEvents.NEW_CONNECTION.value,
+                        TelemetryField.KEY_VALUE.value: str(telemetry_value),
+                    },
+                    timestamp=int(time_in_seconds() * 1000),
+                    connection=snowflake_connection,
+                )
+            )
+            snowflake_telemetry_client.send_batch()
+        except Exception as e:
+            logger.debug(
+                "Failed to send telemetry data for %s event: %s: %s",
+                TelemetryEvents.NEW_CONNECTION.value,
+                type(e).__name__,
+                str(e),
             )
-            if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
-            else super().connect(*cargs, **cparams)
-        )
 
 
 @sa_vnt.listens_for(Table, "before_create")