snowflake-connector-python 5.2.0__cp315-cp315-win_amd64.whl

snowflake/connector/cursor/_chunked_download_reader.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import io
+
+from typing import TYPE_CHECKING
+
+from .._internal.api_client.client_api import CHUNK_SIZE, core_driver
+
+
+if TYPE_CHECKING:
+    from _typeshed import WriteableBuffer
+
+    from .._internal.protobuf_gen.database_driver_v1_pb2 import DownloadStreamHandle
+
+
+class _ChunkedDownloadReader(io.RawIOBase):
+    """Lazily reads a stage file via the Begin/Chunk/Close RPCs.
+
+    Nothing beyond Begin fires until read; each ``read()`` pulls one chunk
+    via :func:`readinto`, so at most one chunk sits in memory. This holds for
+    iteration and for ``read(size)`` with a non-negative *size* — ``read(-1)``
+    / ``readall()`` (the ``io.RawIOBase`` default for a full read) loops
+    ``readinto`` to EOF and accumulates the whole file in memory, inherent to
+    a read-all. The session is released exactly once, on EOF, on error, or on
+    close (including via ``io.IOBase.__del__`` as a safety net) — whichever
+    happens first.
+    """
+
+    def __init__(self, download_handle: DownloadStreamHandle) -> None:
+        super().__init__()
+        self._download_handle = download_handle
+        self._pending = b""
+        self._eof = False
+        self._handle_released = False
+
+    def readable(self) -> bool:
+        return True
+
+    def readinto(self, b: WriteableBuffer) -> int:
+        # Loop rather than pull-once: a chunk with data=b"" and eof=False is a
+        # legal (if unusual) core response, and returning 0 here would make
+        # io.RawIOBase.readall() treat it as EOF and silently truncate.
+        while not self._pending and not self._eof:
+            self._pull_chunk()
+        view = memoryview(b)
+        n = min(len(view), len(self._pending))
+        view[:n] = self._pending[:n]
+        self._pending = self._pending[n:]
+        return n
+
+    def _pull_chunk(self) -> None:
+        """Fetch one core-side chunk into ``_pending``; release on EOF/error."""
+        try:
+            response = core_driver.download_stream_chunk(self._download_handle, CHUNK_SIZE)
+        except BaseException:
+            self._release_handle()
+            raise
+        self._pending = response.data
+        if response.eof:
+            self._eof = True
+            self._release_handle()
+
+    def _release_handle(self) -> None:
+        if self._handle_released:
+            return
+        self._handle_released = True
+        core_driver.download_stream_close(self._download_handle)
+
+    def close(self) -> None:
+        if self.closed:
+            return
+        try:
+            self._release_handle()
+        finally:
+            super().close()

snowflake/connector/cursor/_dict_cursor.py

@@ -0,0 +1,78 @@
+"""Concrete DictCursor — returns dict rows."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from .._internal.cursor import DictRow
+from .._internal.errorhandler import simplified_error_handling
+from ._base import SnowflakeCursorBase
+
+
+class DictCursor(SnowflakeCursorBase):
+    """Cursor returning results as dictionaries with column names as keys.
+
+    Usage::
+
+        with connection.cursor(DictCursor) as cur:
+            cur.execute("SELECT 1 AS id, 'hello' AS name")
+            row = cur.fetchone()
+            # row == {"ID": 1, "NAME": "hello"}
+    """
+
+    @property
+    def _use_dict_result(self) -> bool:
+        return True
+
+    @simplified_error_handling
+    def fetchone(self) -> DictRow | None:
+        """
+        Fetch the next row of a query result set as a dictionary.
+
+        Returns:
+            dict: Next row as a dictionary with column names as keys,
+                  or None when no more data is available
+        """
+        return cast(DictRow | None, self._fetchone())
+
+    @simplified_error_handling
+    def fetchmany(self, size: int | None = None) -> list[DictRow]:
+        """
+        Fetch the next set of rows as dictionaries.
+
+        Args:
+            size (int): Number of rows to fetch (defaults to arraysize)
+
+        Returns:
+            list[dict]: List of rows as dictionaries
+        """
+        return super().fetchmany(size)
+
+    def fetchall(self) -> list[DictRow]:
+        """
+        Fetch all (remaining) rows as dictionaries.
+
+        Returns:
+            list[dict]: List of all remaining rows as dictionaries
+        """
+        return super().fetchall()
+
+    def __next__(self) -> DictRow:
+        """
+        Fetch the next row from the currently executed statement as a dictionary.
+
+        Returns:
+            dict: Next row
+
+        Raises:
+            StopIteration: When no more rows are available
+        """
+        return cast(DictRow, super().__next__())
+
+    def next(self) -> DictRow:
+        """Python 2 compatibility alias for ``__next__``. Returns a dictionary row.
+
+        Raises:
+            StopIteration: When no more rows are available
+        """
+        return self.__next__()

snowflake/connector/cursor/_result_set_wrapper.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from .._internal.api_client.client_api import core_driver
+from .._internal.cursor.result_set_wrapper import ResultSetWrapperBase
+from .._internal.protobuf_gen.database_driver_v1_pb2 import (
+    ResultSetGetChunksResponse,
+)
+from .._internal.statement_utils import get_stream_ptr
+
+
+class _ResultSetWrapper(ResultSetWrapperBase):
+    """Sync result-set handle owner."""
+
+    def get_arrow_stream_ptr(self) -> int:
+        """Fetch the Arrow stream and return the raw C pointer.
+
+        Each call builds a fresh stream from the stored result set data.
+
+        Raises:
+            ProgrammingError: If no handle is held.
+        """
+        handle = self._require_handle()
+        response = core_driver.result_set_get_stream(result_set_handle=handle)
+        return get_stream_ptr(response)
+
+    def get_chunks(self) -> ResultSetGetChunksResponse | None:
+        """Call ``result_set_get_chunks`` on the held handle, or return ``None``.
+
+        Safe to call multiple times and independently of :meth:`get_arrow_stream_ptr` —
+        the core layer re-fetches chunk metadata from Snowflake if the cached copy
+        was already consumed.
+        """
+        if self._handle is None:
+            return None
+        return core_driver.result_set_get_chunks(result_set_handle=self._handle)

snowflake/connector/cursor/_snowflake_cursor.py

@@ -0,0 +1,72 @@
+"""Concrete SnowflakeCursor — returns tuple rows."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from .._internal.cursor import Row
+from .._internal.errorhandler import simplified_error_handling
+from ._base import SnowflakeCursorBase
+
+
+class SnowflakeCursor(SnowflakeCursorBase):
+    """Cursor returning results as tuples (default).
+
+    This is the standard cursor returned by ``connection.cursor()``.
+    """
+
+    @property
+    def _use_dict_result(self) -> bool:
+        return False
+
+    @simplified_error_handling
+    def fetchone(self) -> Row | None:
+        """
+        Fetch the next row of a query result set.
+
+        Returns:
+            tuple: Next row, or None when no more data is available
+        """
+        return cast(Row | None, self._fetchone())
+
+    @simplified_error_handling
+    def fetchmany(self, size: int | None = None) -> list[Row]:
+        """
+        Fetch the next set of rows of a query result.
+
+        Args:
+            size (int): Number of rows to fetch (defaults to arraysize)
+
+        Returns:
+            list[tuple]: List of rows as tuples
+        """
+        return super().fetchmany(size)
+
+    def fetchall(self) -> list[Row]:
+        """
+        Fetch all (remaining) rows of a query result.
+
+        Returns:
+            list[tuple]: List of all remaining rows as tuples
+        """
+        return super().fetchall()
+
+    def __next__(self) -> Row:
+        """
+        Fetch the next row from the currently executed statement.
+
+        Returns:
+            tuple: Next row
+
+        Raises:
+            StopIteration: When no more rows are available
+        """
+        return cast(Row, super().__next__())
+
+    def next(self) -> Row:
+        """Python 2 compatibility alias for ``__next__``. Returns a tuple row.
+
+        Raises:
+            StopIteration: When no more rows are available
+        """
+        return self.__next__()

snowflake/connector/description.py

@@ -0,0 +1,7 @@
+"""BACKWARD COMPATIBILITY MODULE ONLY"""
+
+import platform
+
+
+OPERATING_SYSTEM = platform.system()
+PLATFORM = platform.platform()