snowflake-connector-python 4.1.1__tar.gz → 4.3.0__tar.gz

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/DESCRIPTION.md

@@ -7,7 +7,22 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
-- v4.1.1(TBD)
+- v4.3.0(February 12,2026)
+  - Ensured proper list conversion - the converter runs to_snowflake on all list elements.
+  - Made the parameter `server_session_keep_alive` in `SnowflakeConnection` skip checking for pending async queries, providing faster connection close times especially when many async queries are executed.
+  - Fix string representation of INTERVAL YEAR and INTERVAL MONTH types.
+  - Log a warning when using http protocol for OAuth urls.
+  - Deprecated support for custom revocation error classes in OCSP response cache deserialization. By default, only `RevocationCheckError` exceptions are deserialized from OCSP cache. Custom exception classes can be temporarily enabled by setting the `SNOWFLAKE_ENABLE_CUSTOM_REVOCATION_ERRORS` environment variable to `true` or `1`, but this support will be removed in a future release.
+  - Bumped up vendored `urllib3` to `2.6.3`
+  - Added `force_microseconds_precision` to `cursor.fetch_arrow_all` and `cursor.fetch_pandas_all` to avoid PyArrow schema incosistency between batches.
+
+- v4.2.0(January 07,2026)
+  - Added `SnowflakeCursor.stats` property to expose granular DML statistics (rows inserted, deleted, updated, and duplicates) for operations like CTAS where `rowcount` is insufficient.
+  - Added support for injecting SPCS service identifier token (`SPCS_TOKEN`) into login requests when present in SPCS containers.
+  - Introduced shared library([source code](https://github.com/snowflakedb/universal-driver/tree/main/sf_mini_core)) for extended telemetry to identify and prepare testing platform for native rust extensions.
+  - Added `private_key_passphrase` connection parameter for key pair authentication with encrypted private keys.
+
+- v4.1.1(December 12,2025)
   - Relaxed pandas dependency requirements for Python below 3.12.
   - Changed CRL cache cleanup background task to daemon to avoid blocking main thread.
   - Fixed NO_PROXY issues with PUT operations

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/MANIFEST.in

@@ -4,6 +4,7 @@ include LICENSE.txt
 include NOTICE
 include pyproject.toml
 include src/snowflake/connector/nanoarrow_cpp/ArrowIterator/LICENSE.txt
+include src/snowflake/connector/aio/README.md
 recursive-include src/snowflake/connector py.typed *.py *.pyx *.js
 recursive-include src/snowflake/connector/vendored LICENSE*
 
@@ -13,6 +14,9 @@ exclude src/snowflake/connector/nanoarrow_cpp/ArrowIterator/nanoarrow_arrow_iter
 exclude src/snowflake/connector/nanoarrow_cpp/scripts/.clang-format
 exclude src/snowflake/connector/nanoarrow_cpp/scripts/format.sh
 
+include src/snowflake/connector/minicore __init__.py
+recursive-include src/snowflake/connector/minicore *.so *.dll *.dylib *.a *.h *.lib
+
 exclude .git-blame-ignore-revs
 exclude .pre-commit-config.yaml
 exclude license_header.txt

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-connector-python
-Version: 4.1.1
+Version: 4.3.0
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -68,6 +68,7 @@ Requires-Dist: numpy<=2.2.4; extra == "development"
 Requires-Dist: pendulum!=2.1.1; extra == "development"
 Requires-Dist: pexpect; extra == "development"
 Requires-Dist: pytest<7.5.0; extra == "development"
+Requires-Dist: pytest-asyncio; extra == "development"
 Requires-Dist: pytest-cov; extra == "development"
 Requires-Dist: pytest-rerunfailures<16.0; extra == "development"
 Requires-Dist: pytest-timeout; extra == "development"
@@ -92,7 +93,22 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
-- v4.1.1(TBD)
+- v4.3.0(February 12,2026)
+  - Ensured proper list conversion - the converter runs to_snowflake on all list elements.
+  - Made the parameter `server_session_keep_alive` in `SnowflakeConnection` skip checking for pending async queries, providing faster connection close times especially when many async queries are executed.
+  - Fix string representation of INTERVAL YEAR and INTERVAL MONTH types.
+  - Log a warning when using http protocol for OAuth urls.
+  - Deprecated support for custom revocation error classes in OCSP response cache deserialization. By default, only `RevocationCheckError` exceptions are deserialized from OCSP cache. Custom exception classes can be temporarily enabled by setting the `SNOWFLAKE_ENABLE_CUSTOM_REVOCATION_ERRORS` environment variable to `true` or `1`, but this support will be removed in a future release.
+  - Bumped up vendored `urllib3` to `2.6.3`
+  - Added `force_microseconds_precision` to `cursor.fetch_arrow_all` and `cursor.fetch_pandas_all` to avoid PyArrow schema incosistency between batches.
+
+- v4.2.0(January 07,2026)
+  - Added `SnowflakeCursor.stats` property to expose granular DML statistics (rows inserted, deleted, updated, and duplicates) for operations like CTAS where `rowcount` is insufficient.
+  - Added support for injecting SPCS service identifier token (`SPCS_TOKEN`) into login requests when present in SPCS containers.
+  - Introduced shared library([source code](https://github.com/snowflakedb/universal-driver/tree/main/sf_mini_core)) for extended telemetry to identify and prepare testing platform for native rust extensions.
+  - Added `private_key_passphrase` connection parameter for key pair authentication with encrypted private keys.
+
+- v4.1.1(December 12,2025)
   - Relaxed pandas dependency requirements for Python below 3.12.
   - Changed CRL cache cleanup background task to daemon to avoid blocking main thread.
   - Fixed NO_PROXY issues with PUT operations

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/README.md

@@ -103,6 +103,8 @@ To ensure the authenticity and integrity of the Python package, follow the steps
   Verified OK
   ````
 
-## NOTE
+## Notes
 
 This library currently does not support GCP regional endpoints.  Please ensure that any workloads using through this library do not require support for regional endpoints on GCP.  If you have questions about this, please contact [Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge).
+
+The driver uses Rust library called sf_mini_core, you can find its source code [here](https://github.com/snowflakedb/universal-driver/tree/main/sf_mini_core)

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/pyproject.toml

@@ -15,6 +15,8 @@ build-verbosity = 1
 
 [tool.cibuildwheel.linux]
 archs = ["x86_64", "aarch64"]
+# Exclude pre-built minicore libraries from auditwheel repair
+repair-wheel-command = ""
 
 [tool.cibuildwheel.macos]
 archs = ["x86_64", "arm64"]
@@ -23,3 +25,6 @@ repair-wheel-command = ""
 
 [tool.cibuildwheel.windows]
 archs = ["AMD64"]
+
+[tool.check-manifest]
+ignore-bad-ideas = ["src/snowflake/connector/minicore/**"]

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/setup.cfg

@@ -69,6 +69,13 @@ where = src
 exclude = snowflake.connector.cpp*
 include = snowflake.*
 
+[options.package_data]
+snowflake.connector.minicore = 
+	*.so
+	*.dll
+	*.dylib
+	*.a
+
 [options.entry_points]
 console_scripts = 
 	snowflake-dump-ocsp-response = snowflake.connector.tool.dump_ocsp_response:main
@@ -88,6 +95,7 @@ development =
 	pendulum!=2.1.1
 	pexpect
 	pytest<7.5.0
+	pytest-asyncio
 	pytest-cov
 	pytest-rerunfailures<16.0
 	pytest-timeout

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/setup.py

@@ -186,7 +186,6 @@ class SetDefaultInstallationExtras(egg_info):
 
     def finalize_options(self):
         super().finalize_options()
-
         # if not explicitly excluded, add boto dependencies to install_requires
         if not SNOWFLAKE_NO_BOTO:
             boto_extras = self.distribution.extras_require.get("boto", [])

{snowflake_connector_python-4.1.1 → snowflake_connector_python-4.3.0}/src/snowflake/connector/__init__.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 
 from functools import wraps
 
+from ._utils import _core_loader
+
 apilevel = "2.0"
 threadsafety = 2
 paramstyle = "pyformat"
@@ -45,6 +47,14 @@ from .errors import (
 from .log_configuration import EasyLoggingConfigPython
 from .version import VERSION
 
+# Load the core library - failures are captured in core_loader and don't prevent module loading
+try:
+    _core_loader.load()
+except Exception:
+    # Silently continue if core loading fails - the error is already captured in core_loader
+    # This ensures the connector module loads even if the minicore library is unavailable
+    pass
+
 logging.getLogger(__name__).addHandler(NullHandler())
 setup_external_libraries()
 

snowflake_connector_python-4.3.0/src/snowflake/connector/_utils.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import ctypes
+import importlib
+import logging
+import os
+import platform
+import string
+import threading
+import time
+from enum import Enum
+from inspect import stack
+from pathlib import Path
+from random import choice
+from threading import Timer
+from uuid import UUID
+
+from snowflake.connector.description import ISA, OPERATING_SYSTEM, OS_VERSION
+
+logger = logging.getLogger(__name__)
+
+
+class TempObjectType(Enum):
+    TABLE = "TABLE"
+    VIEW = "VIEW"
+    STAGE = "STAGE"
+    FUNCTION = "FUNCTION"
+    FILE_FORMAT = "FILE_FORMAT"
+    QUERY_TAG = "QUERY_TAG"
+    COLUMN = "COLUMN"
+    PROCEDURE = "PROCEDURE"
+    TABLE_FUNCTION = "TABLE_FUNCTION"
+    DYNAMIC_TABLE = "DYNAMIC_TABLE"
+    AGGREGATE_FUNCTION = "AGGREGATE_FUNCTION"
+    CTE = "CTE"
+
+
+TEMP_OBJECT_NAME_PREFIX = "SNOWPARK_TEMP_"
+ALPHANUMERIC = string.digits + string.ascii_lowercase
+TEMPORARY_STRING = "TEMP"
+SCOPED_TEMPORARY_STRING = "SCOPED TEMPORARY"
+_PYTHON_SNOWPARK_USE_SCOPED_TEMP_OBJECTS_STRING = (
+    "PYTHON_SNOWPARK_USE_SCOPED_TEMP_OBJECTS"
+)
+
+REQUEST_ID_STATEMENT_PARAM_NAME = "requestId"
+
+# Default server side cap on Degree of Parallelism for file transfer
+# This default value is set to 2^30 (~ 10^9), such that it will not
+# throttle regular sessions.
+_DEFAULT_VALUE_SERVER_DOP_CAP_FOR_FILE_TRANSFER = 1 << 30
+# Variable name of server DoP cap for file transfer
+_VARIABLE_NAME_SERVER_DOP_CAP_FOR_FILE_TRANSFER = (
+    "snowflake_server_dop_cap_for_file_transfer"
+)
+
+
+def generate_random_alphanumeric(length: int = 10) -> str:
+    return "".join(choice(ALPHANUMERIC) for _ in range(length))
+
+
+def random_name_for_temp_object(object_type: TempObjectType) -> str:
+    return f"{TEMP_OBJECT_NAME_PREFIX}{object_type.value}_{generate_random_alphanumeric().upper()}"
+
+
+def get_temp_type_for_object(use_scoped_temp_objects: bool) -> str:
+    return SCOPED_TEMPORARY_STRING if use_scoped_temp_objects else TEMPORARY_STRING
+
+
+def is_uuid4(str_or_uuid: str | UUID) -> bool:
+    """Check whether provided string str is a valid UUID version4."""
+    if isinstance(str_or_uuid, UUID):
+        return str_or_uuid.version == 4
+
+    if not isinstance(str_or_uuid, str):
+        return False
+
+    try:
+        uuid_str = str(UUID(str_or_uuid, version=4))
+    except ValueError:
+        return False
+    return uuid_str == str_or_uuid
+
+
+def _snowflake_max_parallelism_for_file_transfer(connection):
+    """Returns the server side cap on max parallelism for file transfer for the given connection."""
+    return getattr(
+        connection,
+        f"_{_VARIABLE_NAME_SERVER_DOP_CAP_FOR_FILE_TRANSFER}",
+        _DEFAULT_VALUE_SERVER_DOP_CAP_FOR_FILE_TRANSFER,
+    )
+
+
+class _TrackedQueryCancellationTimer(Timer):
+    def __init__(self, interval, function, args=None, kwargs=None):
+        super().__init__(interval, function, args, kwargs)
+        self.executed = False
+
+    def run(self):
+        super().run()
+        self.executed = True
+
+
+def get_application_path() -> str:
+    """Get the path of the application script using the connector."""
+    try:
+        outermost_frame = stack()[-1]
+        return outermost_frame.filename
+    except Exception:
+        return "unknown"
+
+
+_SPCS_TOKEN_ENV_VAR_NAME = "SF_SPCS_TOKEN_PATH"
+_SPCS_TOKEN_DEFAULT_PATH = "/snowflake/session/spcs_token"
+
+
+def get_spcs_token() -> str | None:
+    """Return the SPCS token read from the configured path, or None.
+
+    The path is determined by the SF_SPCS_TOKEN_PATH environment variable,
+    falling back to ``/snowflake/session/spcs_token`` when unset.
+
+    Any I/O errors or missing/empty files are treated as \"no token\" and
+    will not cause authentication to fail.
+    """
+    path = os.getenv(_SPCS_TOKEN_ENV_VAR_NAME) or _SPCS_TOKEN_DEFAULT_PATH
+    try:
+        if not os.path.isfile(path):
+            return None
+        with open(path, encoding="utf-8") as f:
+            token = f.read().strip()
+        if not token:
+            return None
+        return token
+    except Exception as exc:  # pragma: no cover - best-effort logging only
+        logger.debug("Failed to read SPCS token from %s: %s", path, exc)
+        return None
+
+
+class _NanoarrowLoader:
+    def __init__(self):
+        self._error: Exception | None = None
+
+    def set_load_error(self, err: Exception):
+        self._error = err
+
+    def get_load_error(self) -> str:
+        return str(self._error)
+
+
+class _CoreLoader:
+    def __init__(self):
+        self._version: bytes | None = None
+        self._error: Exception | None = None
+        self._path: str | None = None
+        self._load_time: float | None = None
+
+    @staticmethod
+    def _detect_os() -> str:
+        """Detect the operating system."""
+        system = platform.system().lower()
+        if system == "linux":
+            return "linux"
+        elif system == "darwin":
+            return "macos"
+        elif system == "windows":
+            return "windows"
+        elif system == "aix":
+            return "aix"
+        else:
+            return "unknown"
+
+    @staticmethod
+    def _detect_arch() -> str:
+        """Detect the CPU architecture."""
+        machine = platform.machine().lower()
+        if machine in ("x86_64", "amd64"):
+            return "x86_64"
+        elif machine in ("aarch64", "arm64"):
+            return "aarch64"
+        elif machine in ("i686", "i386", "x86"):
+            return "i686"
+        elif machine == "ppc64":
+            return "ppc64"
+        else:
+            return "unknown"
+
+    @staticmethod
+    def _detect_libc() -> str:
+        """Detect libc type on Linux (glibc vs musl)."""
+        # Check if we're on Alpine/musl
+        if Path("/etc/alpine-release").exists():
+            return "musl"
+
+        # Check for musl by looking at the libc library
+        try:
+            import subprocess
+
+            result = subprocess.run(
+                ["ldd", "--version"],
+                capture_output=True,
+                text=True,
+            )
+            if "musl" in result.stdout.lower() or "musl" in result.stderr.lower():
+                return "musl"
+        except Exception:
+            pass
+
+        # Default to glibc
+        return "glibc"
+
+    @staticmethod
+    def _get_platform_subdir() -> str:
+        """Get the platform-specific subdirectory name."""
+        os_name = _CoreLoader._detect_os()
+        arch = _CoreLoader._detect_arch()
+
+        if os_name == "linux":
+            libc = _CoreLoader._detect_libc()
+            return f"linux_{arch}_{libc}"
+        elif os_name == "macos":
+            return f"macos_{arch}"
+        elif os_name == "windows":
+            return f"windows_{arch}"
+        elif os_name == "aix":
+            return f"aix_{arch}"
+
+        raise OSError(f"Mini core binary for {os_name} {arch} not found")
+
+    @staticmethod
+    def _get_lib_name() -> str:
+        """Get the library filename for the current platform."""
+        os_name = _CoreLoader._detect_os()
+        if os_name == "windows":
+            return "sf_mini_core.dll"
+        elif os_name == "macos":
+            return "libsf_mini_core.dylib"
+        elif os_name == "aix":
+            return "libsf_mini_core.a"
+        else:
+            # Linux and other Unix-like systems
+            return "libsf_mini_core.so"
+
+    @staticmethod
+    def _get_core_path():
+        """Get the path to the minicore library for the current platform."""
+        subdir = _CoreLoader._get_platform_subdir()
+        lib_name = _CoreLoader._get_lib_name()
+
+        files = importlib.resources.files("snowflake.connector.minicore")
+
+        return files.joinpath(subdir, lib_name)
+
+    @staticmethod
+    def _register_functions(core: ctypes.CDLL):
+        core.sf_core_full_version.argtypes = []
+        core.sf_core_full_version.restype = ctypes.c_char_p
+
+    @staticmethod
+    def _load_minicore(path: str) -> ctypes.CDLL:
+        # This context manager is the safe way to get a
+        # file path from importlib.resources. It handles cases
+        # where the file is inside a zip and needs to be extracted
+        # to a temporary location.
+        with importlib.resources.as_file(path) as lib_path:
+            core = ctypes.CDLL(str(lib_path))
+        return core
+
+    def get_present_binaries(self) -> str:
+        present_binaries = []
+        try:
+            minicore_files = importlib.resources.files("snowflake.connector.minicore")
+            # Iterate through all items in the minicore module
+            for item in minicore_files.iterdir():
+                # Skip non-platform directories like __pycache__
+                if item.is_dir() and not item.name.startswith("__"):
+                    # This is a platform subdirectory
+                    platform_name = item.name
+                    try:
+                        # List all files in this subdirectory
+                        for binary_file in item.iterdir():
+                            if binary_file.is_file():
+                                # Store as "platform/filename"
+                                present_binaries.append(
+                                    f"{platform_name}/{binary_file.name}"
+                                )
+                    except Exception as e:
+                        logger.debug(f"Error listing binaries in {platform_name}: {e}")
+        except Exception as e:
+            logger.debug(f"Error populating present binaries: {e}")
+
+        return ",".join(present_binaries)
+
+    def _is_core_disabled(self) -> bool:
+        value = str(os.getenv("SNOWFLAKE_DISABLE_MINICORE", None)).lower()
+        return value in ["1", "true"]
+
+    def _load(self) -> None:
+        start_time = time.perf_counter()
+        try:
+            path = self._get_core_path()
+            self._path = str(path)
+            core = self._load_minicore(path)
+            self._register_functions(core)
+            self._version = core.sf_core_full_version()
+            self._error = None
+        except Exception as err:
+            self._error = err
+        end_time = time.perf_counter()
+        # Store load time in milliseconds (with sub-millisecond precision)
+        self._load_time = (end_time - start_time) * 1000
+
+    def load(self):
+        """Spawn a separate thread to load the minicore library (non-blocking)."""
+        if self._is_core_disabled():
+            self._error = "mini-core-disabled"
+            return
+        self._error = "still-loading"
+        thread = threading.Thread(target=self._load, daemon=True)
+        thread.start()
+
+    def get_load_error(self) -> str:
+        return str(self._error)
+
+    def get_core_version(self) -> str | None:
+        if self._version:
+            try:
+                return self._version.decode("utf-8")
+            except Exception:
+                pass
+        return None
+
+    def get_file_name(self) -> str:
+        return self._path
+
+    def get_load_time(self) -> float | None:
+        """Return the time it took to load the minicore binary in milliseconds."""
+        return self._load_time
+
+
+_core_loader = _CoreLoader()
+_nanoarrow_loader = _NanoarrowLoader()
+
+
+def build_minicore_usage_for_session() -> dict[str, str | None]:
+    return {
+        "ISA": ISA,
+        "CORE_VERSION": _core_loader.get_core_version(),
+        "CORE_FILE_NAME": _core_loader.get_file_name(),
+    }
+
+
+def build_minicore_usage_for_telemetry() -> dict[str, str | None]:
+    return {
+        "OS": OPERATING_SYSTEM,
+        "OS_VERSION": OS_VERSION,
+        "CORE_LOAD_ERROR": _core_loader.get_load_error(),
+        "CORE_BINARIES_PRESENT": _core_loader.get_present_binaries(),
+        "CORE_LOAD_TIME": _core_loader.get_load_time(),
+        **build_minicore_usage_for_session(),
+    }
+
+
+def build_nanoarrow_usage_for_telemetry() -> dict[str, str | None]:
+    return {
+        "OS": OPERATING_SYSTEM,
+        "OS_VERSION": OS_VERSION,
+        "NANOARROW_LOAD_ERROR": _nanoarrow_loader.get_load_error(),
+        "ISA": ISA,
+    }

snowflake_connector_python-4.3.0/src/snowflake/connector/aio/README.md

@@ -0,0 +1,88 @@
+# Notice
+
+**This component is a Preview feature provided for experimental purposes only.
+It is provided "AS IS" and without warranty of any kind. This module is not
+supported by Snowflake Support. Use of this code is at your own risk and it
+is not intended for production environments.**
+
+## Features NOT Supported
+
+
+- ❌ `conn.errorhandler` (get/set) - no support for async errorhandlers
+- ❌ `enable_connection_diag=True` - no connection diagnostic
+- ❌ `authenticator='PAT_WITH_EXTERNAL_SESSION'` - not supported
+- ❌ `mfa_callback` / `password_callback` - not supported
+- ❌ `_probe_connection=True` - no connection diagnostic
+- ❌ Raw binary response handling - not supported
+- ❌ CRL (Certificate Revocation List) - not supported (only OCSP is supported)
+
+## Installation & Import
+
+Using aio version requires additional installation of `aiohttp` dependency.
+
+```python
+# Same package, different import
+from snowflake.connector.aio import connect, SnowflakeConnection, DictCursor
+```
+
+
+## Connection Patterns
+
+
+```python
+# Pattern 1: Async context manager (recommended)
+async with connect(user='...', password='...', account='...') as conn:
+   # Use connection
+   pass
+
+
+# Pattern 2: Direct await
+conn = await connect(user='...', password='...', account='...')
+await conn.close()
+
+
+# Pattern 3: Manual
+conn = SnowflakeConnection(user='...', password='...', account='...')
+await conn.connect()
+await conn.close()
+```
+
+
+## Basic Operations Comparison
+
+
+| Operation | Sync | Async |
+|-----------|------|-------|
+| **Connect** | `conn = connect(...)` | `conn = await connect(...)` |
+| **Create cursor** | `cur = conn.cursor()` | `cur = conn.cursor()` *(same)* |
+| **Execute** | `cur.execute(sql)` | `await cur.execute(sql)` |
+| **Fetch one** | `cur.fetchone()` | `await cur.fetchone()` |
+| **Fetch many** | `cur.fetchmany(n)` | `await cur.fetchmany(n)` |
+| **Fetch all** | `cur.fetchall()` | `await cur.fetchall()` |
+| **Iterate** | `for row in cur:` | `async for row in cur:` |
+| **Commit** | `conn.commit()` | `await conn.commit()` |
+| **Rollback** | `conn.rollback()` | `await conn.rollback()` |
+| **Close** | `conn.close()` | `await conn.close()` |
+
+
+## Quick Examples
+
+
+### Simple Query
+
+
+```python
+import asyncio
+from snowflake.connector.aio import connect
+
+
+async def query_data():
+   async with connect(user='...', password='...', account='...') as conn:
+       async with conn.cursor() as cur:
+           await cur.execute("SELECT * FROM table WHERE id < %s", (100,))
+           async for row in cur:
+               print(row)
+
+
+asyncio.run(query_data())
+```