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

snowflake/connector/_internal/text_utils.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import re
+
+from collections.abc import Iterator
+from io import StringIO
+
+from snowflake.connector._core import sf_core_python
+
+
+_VALUES_CLAUSE_RE = re.compile(r"\bVALUES\s*\(", re.IGNORECASE)
+
+# Matches only the tokens that affect parser state.  Two-char tokens are
+# listed first so the alternation is greedy and consumes them whole:
+#   $$   — dollar-quote delimiter
+#   ''   — escaped single-quote inside a single-quoted string
+#   ""   — escaped double-quote inside a double-quoted string
+#   ( ) ' "  — individual state-change characters
+# Everything between tokens is skipped at C speed by the regex engine,
+# avoiding a Python-level loop over every character.
+_SQL_TOKENS_RE = re.compile(r"\$\$|''|\"\"|[()'\"]")
+
+
+def extract_values_clause(sql: str) -> str | None:
+    """Extract the VALUES clause from an INSERT SQL statement.
+
+    Uses a balanced-parentheses parser rather than a greedy regex so that
+    nested function calls (e.g. ``PARSE_JSON(%(col)s)``) and string literals
+    that contain parentheses are handled correctly.
+
+    Examples that a greedy regex gets wrong but this function handles:
+
+    * ``INSERT INTO t (raw) (SELECT PARSE_JSON(c) as raw FROM VALUES (%(raw)s))``
+      → returns ``(%(raw)s)``  (greedy regex returns ``(%(raw)s))``)
+    * ``INSERT INTO t (col) VALUES (PARSE_JSON(%(col)s))``
+      → returns ``(PARSE_JSON(%(col)s))``
+
+    Returns:
+        The VALUES clause including its outer parentheses, e.g. ``(%(col)s)``,
+        or ``None`` when no balanced VALUES clause can be found.
+    """
+    m = _VALUES_CLAUSE_RE.search(sql)
+    if not m:
+        return None
+
+    start = m.end() - 1  # position of the opening '('
+    depth = 0
+    in_single_quote = False
+    in_double_quote = False
+    in_dollar_quote = False
+
+    for tok in _SQL_TOKENS_RE.finditer(sql, start):
+        t = tok.group()
+
+        if in_dollar_quote:
+            if t == "$$":
+                in_dollar_quote = False
+        elif in_single_quote:
+            if t == "'":
+                in_single_quote = False
+            # t == "''" → escaped quote, stay in string (fall through, do nothing)
+        elif in_double_quote:
+            if t == '"':
+                in_double_quote = False
+            # t == '""' → escaped quote, stay in string (fall through, do nothing)
+        else:
+            if t == "(":
+                depth += 1
+            elif t == ")":
+                depth -= 1
+                if depth == 0:
+                    return sql[start : tok.end()]
+            elif t == "'":
+                in_single_quote = True
+            elif t == '"':
+                in_double_quote = True
+            elif t == "$$":
+                in_dollar_quote = True
+
+    return None  # unbalanced or no VALUES clause found
+
+
+class SQLDelimiter:
+    """Delimiter read from ``sql_delimiter`` when :func:`split_statements` is called."""
+
+    def __str__(self) -> str:
+        return self.sql_delimiter
+
+    def __init__(self, sql_delimiter: str = ";") -> None:
+        self.sql_delimiter = sql_delimiter
+
+
+def split_statements(
+    buf: StringIO,
+    remove_comments: bool = False,
+    delimiter: SQLDelimiter | None = None,
+) -> Iterator[tuple[str, bool | None]]:
+    """Yield SQL statements and ``!`` commands from ``buf``.
+
+    A delimiter inside a quote, ``$$`` body, or comment does not end a statement.
+    An unterminated quote, block comment, or dollar quote stays open through the
+    rest of the script. Each statement's delimiter is rewritten as ``;``. The
+    second item is ``True`` for ``PUT`` and ``GET``, ``False`` for other
+    statements and commands, and ``None`` when the text is empty or comment-only.
+    """
+    if delimiter is None:
+        delimiter = SQLDelimiter()
+    yield from sf_core_python.split_sql_script(
+        buf.read(),
+        delimiter.sql_delimiter,
+        remove_comments,
+    )

snowflake/connector/_internal/type_codes.py

@@ -0,0 +1,139 @@
+"""
+Type code mappings for Snowflake data types to PEP 249 DB API 2.0.
+
+Maps Snowflake type names to integer type codes for cursor.description.
+"""
+
+# Type code constants for PEP 249 compliance
+# These match the indices from snowflake-connector-python for compatibility
+FIXED = 0
+REAL = 1
+TEXT = 2
+DATE = 3
+TIMESTAMP = 4
+VARIANT = 5
+TIMESTAMP_LTZ = 6
+TIMESTAMP_TZ = 7
+TIMESTAMP_NTZ = 8
+OBJECT = 9
+ARRAY = 10
+BINARY = 11
+TIME = 12
+BOOLEAN = 13
+GEOGRAPHY = 14
+GEOMETRY = 15
+VECTOR = 16
+MAP = 17
+FILE = 18
+INTERVAL_YEAR_MONTH = 19
+INTERVAL_DAY_TIME = 20
+
+# Mapping from Snowflake type name to type code
+SNOWFLAKE_TYPE_TO_CODE = {
+    "FIXED": FIXED,
+    "NUMBER": FIXED,
+    "DECIMAL": FIXED,
+    "NUMERIC": FIXED,
+    "INT": FIXED,
+    "INTEGER": FIXED,
+    "BIGINT": FIXED,
+    "SMALLINT": FIXED,
+    "TINYINT": FIXED,
+    "BYTEINT": FIXED,
+    "DECFLOAT": FIXED,
+    "REAL": REAL,
+    "FLOAT": REAL,
+    "FLOAT4": REAL,
+    "FLOAT8": REAL,
+    "DOUBLE": REAL,
+    "DOUBLE PRECISION": REAL,
+    "TEXT": TEXT,
+    "VARCHAR": TEXT,
+    "CHAR": TEXT,
+    "CHARACTER": TEXT,
+    "STRING": TEXT,
+    "DATE": DATE,
+    "DATETIME": TIMESTAMP,
+    "TIMESTAMP": TIMESTAMP,
+    "TIMESTAMP_LTZ": TIMESTAMP_LTZ,
+    "TIMESTAMP_NTZ": TIMESTAMP_NTZ,
+    "TIMESTAMP_TZ": TIMESTAMP_TZ,
+    "TIME": TIME,
+    "VARIANT": VARIANT,
+    "OBJECT": OBJECT,
+    "ARRAY": ARRAY,
+    "BINARY": BINARY,
+    "VARBINARY": BINARY,
+    "BOOLEAN": BOOLEAN,
+    "GEOGRAPHY": GEOGRAPHY,
+    "GEOMETRY": GEOMETRY,
+    "VECTOR": VECTOR,
+    "MAP": MAP,
+    "FILE": FILE,
+    "INTERVAL_YEAR_MONTH": INTERVAL_YEAR_MONTH,
+    "INTERVAL_DAY_TIME": INTERVAL_DAY_TIME,
+}
+
+# Python type name to Snowflake type name mapping.
+# Used by JsonBindingConverter to infer the Snowflake type from a Python value.
+# Mirrors PYTHON_TO_SNOWFLAKE_TYPE from the reference connector's converter.py.
+PYTHON_TO_SNOWFLAKE_TYPE = {
+    "int": "FIXED",
+    "long": "FIXED",
+    "float": "REAL",
+    "str": "TEXT",
+    "unicode": "TEXT",
+    "bool": "BOOLEAN",
+    "bytes": "BINARY",
+    "bytearray": "BINARY",
+    "datetime": "TIMESTAMP_NTZ",
+    "date": "DATE",
+    "time": "TIME",
+    "decimal": "FIXED",
+    "struct_time": "TIMESTAMP_NTZ",
+    "timedelta": "TIME",
+    "nonetype": "ANY",
+}
+
+
+def get_type_code(snowflake_type: str) -> int:
+    """
+    Get the type code for a Snowflake type name.
+
+    Args:
+        snowflake_type: Snowflake type name (e.g., "FIXED", "TEXT", "TIMESTAMP_NTZ")
+
+    Returns:
+        int: Type code for PEP 249 compliance
+    """
+    # Normalize type name: uppercase and strip leading/trailing whitespace (preserve internal spaces)
+    normalized_type = snowflake_type.upper().strip()
+    return SNOWFLAKE_TYPE_TO_CODE.get(normalized_type, TEXT)  # Default to TEXT if unknown
+
+
+# Reverse mapping: type code → canonical Snowflake type name.
+# Re-exported by snowflake.connector.constants for backward compatibility with
+# code written against the old snowflake-connector-python driver (e.g. dbt-snowflake).
+FIELD_ID_TO_NAME: dict[int, str] = {
+    FIXED: "FIXED",
+    REAL: "REAL",
+    TEXT: "TEXT",
+    DATE: "DATE",
+    TIMESTAMP: "TIMESTAMP",
+    VARIANT: "VARIANT",
+    TIMESTAMP_LTZ: "TIMESTAMP_LTZ",
+    TIMESTAMP_TZ: "TIMESTAMP_TZ",
+    TIMESTAMP_NTZ: "TIMESTAMP_NTZ",
+    OBJECT: "OBJECT",
+    ARRAY: "ARRAY",
+    BINARY: "BINARY",
+    TIME: "TIME",
+    BOOLEAN: "BOOLEAN",
+    GEOGRAPHY: "GEOGRAPHY",
+    GEOMETRY: "GEOMETRY",
+    VECTOR: "VECTOR",
+    MAP: "MAP",
+    FILE: "FILE",
+    INTERVAL_YEAR_MONTH: "INTERVAL_YEAR_MONTH",
+    INTERVAL_DAY_TIME: "INTERVAL_DAY_TIME",
+}

snowflake/connector/_internal/utils.py

@@ -0,0 +1,65 @@
+"""General-purpose internal utilities shared across subsystems."""
+
+from __future__ import annotations
+
+import inspect
+
+from collections.abc import Iterable, Sequence
+from typing import Any, cast
+
+from ..errors import ProgrammingError
+from .errorcode import ER_INVALID_VALUE
+
+
+_ExecutemanyRow = Sequence[Any] | dict[str, Any]
+
+
+def get_application_path() -> str | None:
+    # Outermost frame of the calling thread, as in the old connector: reports threading.py from a
+    # worker thread and "<stdin>" from a REPL.
+    try:
+        return inspect.stack(context=0)[-1].filename
+    except Exception:
+        return None
+
+
+def _resolve_alias(
+    canonical: object,
+    alias: object,
+    canonical_name: str,
+    alias_name: str,
+) -> object:
+    """Return the resolved value from a canonical/legacy-alias pair.
+
+    Raises ProgrammingError if both are provided.
+    """
+    if canonical is not None and alias is not None:
+        raise ProgrammingError(
+            msg=f"Cannot supply both '{canonical_name}' and '{alias_name}'; pass one only.",
+            errno=ER_INVALID_VALUE,
+        )
+    return alias if alias is not None else canonical
+
+
+def _coerce_executemany_params(seq_of_parameters: object) -> Sequence[_ExecutemanyRow]:
+    """Return a random-access sequence of ``executemany`` parameter rows.
+
+    Array binding peeks at the first row, transposes every row, then may walk the
+    same collection again on the per-row fallback. Non-sequences (generators,
+    ``map``, one-shot iterators) are therefore materialized once. Lists and
+    tuples are left unchanged.
+    """
+    if seq_of_parameters is None:
+        return ()
+    if isinstance(seq_of_parameters, Sequence):
+        return seq_of_parameters
+    if not isinstance(seq_of_parameters, Iterable):
+        raise ProgrammingError(
+            msg=(
+                "executemany() seq_of_parameters must be an iterable of parameter "
+                f"sequences or dicts, got {type(seq_of_parameters).__name__}. "
+                "Pass a list, tuple, or other iterable of rows."
+            ),
+            errno=ER_INVALID_VALUE,
+        )
+    return cast("Sequence[_ExecutemanyRow]", list(seq_of_parameters))