snowflake-snowpark-python 1.54.0__tar.gz → 1.55.0__tar.gz

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Release History
 
+## 1.55.0 (2026-09-10)
+
+### Snowpark Python API Updates
+
+#### New Features
+
+- Added `DataFrame.to_polars()` to convert a Snowpark DataFrame to a Polars DataFrame. Supports an optional `transport="parquet"` mode for large data-transfer-dominated workloads.
+- Added interval type support for Python UDFs and stored procedures. Use `datetime.timedelta` as the type annotation for day-time interval (`DayTimeIntervalType`) parameters and return values, and `YearMonthInterval` (a type annotation sentinel from `snowflake.snowpark.types`) for year-month interval (`YearMonthIntervalType`) parameters and return values.
+- Added support for a `table_properties` key in the `iceberg_config` dictionary of `DataFrameWriter.save_as_table`, which emits a `TABLE_PROPERTIES = ('k'='v', ...)` clause on Iceberg table creation (CREATE / CTAS).
+
+#### Bug Fixes
+
+- Fixed registering a UDF, UDTF, or stored procedure with an integer optional argument failing with `SQL compilation error: invalid default argument expression`. Integer defaults were emitted as `DEFAULT <value> :: INT`, and a parameter default only accepts a constant expression. The redundant cast is no longer generated.
+
+#### Documentation
+
+- Documented the JSON Schema `response_format` shape for `ai_extract` and `DataFrame.ai.extract`.
+
+#### Other Changes
+
+- Test-only: fixed `test_generator_table_function` failing as `assert 0 < 0` on the `seq2(0)` + `generator(timelimit => 1)` case. `seq2(0)` passes sign=0, so it continues at 0 after 32767, and a one-second generator run usually emits far more than one 32768-value cycle, making `ORDER BY seq2(0) LIMIT 3` return `0, 0, 0`. That assertion now allows equal values; the `seq1(1)` + `rowcount` assertions stay strictly increasing.
+
+### Snowpark pandas API Updates
+
+#### Bug Fixes
+
+- Fixed a bug where referencing `modin.pandas` inside a Snowpark pandas `apply()` function raised a `ModuleNotFoundError`.
+
 ## 1.54.0 (2026-07-29)
 
 ### Snowpark Python API updates

{snowflake_snowpark_python-1.54.0/src/snowflake_snowpark_python.egg-info → snowflake_snowpark_python-1.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-snowpark-python
-Version: 1.54.0
+Version: 1.55.0
 Summary: Snowflake Snowpark for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -77,6 +77,7 @@ Requires-Dist: snowflake.core<2,>=1.0.0; extra == "development"
 Requires-Dist: psutil; extra == "development"
 Requires-Dist: lxml; extra == "development"
 Requires-Dist: pyarrow; extra == "development"
+Requires-Dist: polars>=1.0; extra == "development"
 Provides-Extra: modin-development
 Requires-Dist: snowflake-connector-python[pandas]<5.0.0,>=3.17.0; extra == "modin-development"
 Requires-Dist: pandas<3.0.0; extra == "modin-development"
@@ -103,6 +104,7 @@ Requires-Dist: snowflake.core<2,>=1.0.0; extra == "modin-development"
 Requires-Dist: psutil; extra == "modin-development"
 Requires-Dist: lxml; extra == "modin-development"
 Requires-Dist: pyarrow; extra == "modin-development"
+Requires-Dist: polars>=1.0; extra == "modin-development"
 Requires-Dist: scipy<=1.16.3; extra == "modin-development"
 Requires-Dist: statsmodels; extra == "modin-development"
 Requires-Dist: scikit-learn; extra == "modin-development"

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/setup.py

@@ -73,6 +73,7 @@ DEVELOPMENT_REQUIREMENTS = [
     "psutil",  # testing for telemetry
     "lxml",  # used in XML reader unit tests
     "pyarrow",  # used in dataframe reader tests
+    "polars>=1.0",  # used in test_df_to_polars integration tests
 ]
 MODIN_DEVELOPMENT_REQUIREMENTS = [
     # Snowpark pandas 3rd party library testing. Cap the scipy version because

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/analyzer_utils.py

@@ -150,6 +150,7 @@ BASE_LOCATION = " BASE_LOCATION "
 TARGET_FILE_SIZE = " TARGET_FILE_SIZE "
 CATALOG_SYNC = " CATALOG_SYNC "
 STORAGE_SERIALIZATION_POLICY = " STORAGE_SERIALIZATION_POLICY "
+TABLE_PROPERTIES = " TABLE_PROPERTIES"
 REG_EXP = " REGEXP "
 COLLATE = " COLLATE "
 RESULT_SCAN = " RESULT_SCAN"
@@ -334,6 +335,30 @@ def iceberg_partition_clause(partition_exprs: List[str]) -> str:
     )
 
 
+def iceberg_table_properties_clause(iceberg_config: Optional[dict]) -> str:
+    """Emit ``TABLE_PROPERTIES = ('k'='v', ...)`` from an ``iceberg_config``'s
+    ``table_properties`` map (keys kept verbatim, keys/values escaped); empty
+    when absent."""
+    if not iceberg_config:
+        return EMPTY_STRING
+    normalized = {k.lower(): v for k, v in iceberg_config.items()}
+    table_properties = normalized.get("table_properties")
+    if not table_properties:
+        return EMPTY_STRING
+
+    # Escape via ``escape_quotes_and_backslashes`` (not ``single_quote``): it
+    # escapes backslashes as well as quotes and never skips escaping, so a
+    # crafted key/value cannot break out of its literal and inject extra SQL
+    # (e.g. "'x', 'injected'='surprise'" or "x\\') COPY GRANTS --").
+    def _quote(value: object) -> str:
+        return SINGLE_QUOTE + escape_quotes_and_backslashes(str(value)) + SINGLE_QUOTE
+
+    pairs = COMMA.join(f"{_quote(k)}={_quote(v)}" for k, v in table_properties.items())
+    return (
+        SPACE + TABLE_PROPERTIES + EQUALS + LEFT_PARENTHESIS + pairs + RIGHT_PARENTHESIS
+    )
+
+
 def order_by_spec(col_exprs: List[str]) -> str:
     if not col_exprs:
         return EMPTY_STRING
@@ -1168,13 +1193,14 @@ def create_table_statement(
     options_statement = get_options_statement(options)
 
     partition_by_clause = iceberg_partition_clause(partition_exprs)
+    table_properties_clause = iceberg_table_properties_clause(iceberg_config)
 
     return (
         f"{CREATE}{(OR + REPLACE) if replace else EMPTY_STRING}"
         f" {(get_temp_type_for_object(use_scoped_temp_objects, is_generated) if table_type.lower() in TEMPORARY_STRING_SET else table_type).upper()} "
         f"{ICEBERG if iceberg_options else EMPTY_STRING}{TABLE}{table_name}{(IF + NOT + EXISTS) if not replace and not error else EMPTY_STRING}"
         f"{LEFT_PARENTHESIS}{schema}{RIGHT_PARENTHESIS}{partition_by_clause}{cluster_by_clause}"
-        f"{options_statement}{COPY_GRANTS if copy_grants else EMPTY_STRING}{comment_sql}"
+        f"{options_statement}{table_properties_clause}{COPY_GRANTS if copy_grants else EMPTY_STRING}{comment_sql}"
     )
 
 
@@ -1259,13 +1285,14 @@ def create_table_as_select_statement(
     options_statement = get_options_statement(options)
 
     partition_by_clause = iceberg_partition_clause(partition_exprs)
+    table_properties_clause = iceberg_table_properties_clause(iceberg_config)
 
     return (
         f"{CREATE}{OR + REPLACE if replace else EMPTY_STRING}"
         f" {(get_temp_type_for_object(use_scoped_temp_objects, is_generated) if table_type.lower() in TEMPORARY_STRING_SET else table_type).upper()} "
         f"{ICEBERG if iceberg_options else EMPTY_STRING}{TABLE}"
         f"{IF + NOT + EXISTS if not replace and not error else EMPTY_STRING} "
-        f"{table_name}{column_definition_sql}{partition_by_clause}{cluster_by_clause}{options_statement}"
+        f"{table_name}{column_definition_sql}{partition_by_clause}{cluster_by_clause}{options_statement}{table_properties_clause}"
         f"{COPY_GRANTS if copy_grants else EMPTY_STRING}{comment_sql} {AS}{project_statement([], child)}"
     )
 

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/datatype_mapper.py

@@ -331,6 +331,25 @@ def to_sql_no_cast(
     return f"{value}"
 
 
+def to_sql_for_default_arg(value: Any, datatype: DataType) -> str:
+    """Convert a value with DataType to SQL usable as a parameter's DEFAULT.
+
+    Identical to :func:`to_sql` except that integral values are emitted as bare
+    literals rather than ``<value> :: INT``. A DEFAULT only accepts a constant
+    expression, and the parameter already declares its own type, so the cast is
+    redundant. Snowflake rejects it outright on some server versions with
+    ``invalid default argument expression`` (SNOW-4013704).
+    """
+    if isinstance(datatype, _IntegralType):
+        if value is None:
+            return "NULL"
+        if isinstance(value, int):
+            # bool is a subclass of int, so normalize it to 0/1 for an
+            # integral parameter rather than emitting True/False.
+            return str(int(value))
+    return to_sql(value, datatype)
+
+
 def to_sql(
     value: Any,
     datatype: DataType,
@@ -501,6 +520,31 @@ def to_sql(
     if isinstance(value, str) and isinstance(datatype, DayTimeIntervalType):
         return f"{str_to_sql_for_day_time_interval(value, datatype)} :: {convert_sp_to_sf_type(datatype)}"
 
+    if isinstance(value, timedelta) and isinstance(datatype, DayTimeIntervalType):
+        # Serialize timedelta as an INTERVAL DAY TO SECOND literal.
+        # timedelta stores (days, seconds, microseconds) all non-negative after normalization.
+        sign = "-" if value < timedelta(0) else "+"
+        abs_val = abs(value)
+        d = abs_val.days
+        total_us = abs_val.seconds * 1_000_000 + abs_val.microseconds
+        h = total_us // 3_600_000_000
+        total_us %= 3_600_000_000
+        m = total_us // 60_000_000
+        total_us %= 60_000_000
+        s = total_us // 1_000_000
+        us = total_us % 1_000_000
+        interval_str = f"{sign}{d} {h:02d}:{m:02d}:{s:02d}.{us:06d}"
+        return f"INTERVAL '{interval_str}' DAY TO SECOND :: {convert_sp_to_sf_type(datatype)}"
+
+    if isinstance(value, int) and isinstance(datatype, YearMonthIntervalType):
+        # Serialize int (total months) as an INTERVAL YEAR TO MONTH literal.
+        sign = "-" if value < 0 else "+"
+        abs_months = abs(value)
+        years = abs_months // 12
+        months = abs_months % 12
+        interval_str = f"{sign}{years}-{months:02d}"
+        return f"INTERVAL '{interval_str}' YEAR TO MONTH :: {convert_sp_to_sf_type(datatype)}"
+
     raise TypeError(f"Unsupported datatype {datatype}, value {value} by to_sql()")
 
 

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/select_statement.py

@@ -592,8 +592,10 @@ class SelectableEntity(Selectable):
         self._attributes: Optional[List[Attribute]] = None
         self.table_reference = self.entity.name
         if self.entity.iceberg_changes_config is not None:
-            self.table_reference += (
-                self.entity.iceberg_changes_config.generate_sql_clause()
+            self.table_reference = (
+                self.entity.iceberg_changes_config.generate_table_reference(
+                    self.entity.name
+                )
             )
         elif self.entity.time_travel_config is not None:
             self.table_reference += self.entity.time_travel_config.generate_sql_clause()

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py

@@ -1067,8 +1067,10 @@ class SnowflakePlanBuilder:
         table_reference = table_name
         if isinstance(source_plan, SnowflakeTable):
             if source_plan.iceberg_changes_config:
-                table_reference += (
-                    source_plan.iceberg_changes_config.generate_sql_clause()
+                table_reference = (
+                    source_plan.iceberg_changes_config.generate_table_reference(
+                        table_name
+                    )
                 )
             elif source_plan.time_travel_config:
                 table_reference += source_plan.time_travel_config.generate_sql_clause()
@@ -1316,6 +1318,8 @@ class SnowflakePlanBuilder:
                 catalog_sync: optionally sets the catalog integration configured for Polaris Catalog
                 storage_serialization_policy: specifies the storage serialization policy for the table
                 iceberg_version: Overrides the version of iceberg to use. Defaults to 2 when unset.
+                table_properties: optional mapping of Iceberg property names to values, emitted
+                    verbatim as a ``TABLE_PROPERTIES = ('k'='v', ...)`` clause on CREATE / CTAS.
             table_exists: whether the table already exists in the database.
                 Only used for APPEND and TRUNCATE mode.
         """

snowflake_snowpark_python-1.55.0/src/snowflake/snowpark/_internal/polars_backend.py

@@ -0,0 +1,135 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+from __future__ import annotations
+
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import polars as pl
+    from snowflake.snowpark.dataframe import DataFrame
+
+
+def _empty_frame_from_schema(
+    df: DataFrame, statement_params: dict[str, str] | None
+) -> pl.DataFrame:
+    """Return an empty polars DataFrame with the DataFrame's schema."""
+    import polars as pl
+
+    return pl.from_arrow(
+        df.limit(0).to_arrow(
+            statement_params=statement_params,
+            _emit_ast=False,
+        )
+    )
+
+
+def _open_stage_files_parallel(
+    session,
+    paths: list[str],
+    is_sproc: bool,
+    max_workers: int | None = None,
+) -> list:
+    """Open stage files concurrently, reading each with ``pl.read_parquet``
+    and returning the resulting ``pl.DataFrame`` (``with`` closes the handle
+    after read).
+
+    Uses ``SnowflakeFile.open`` inside a stored procedure and
+    ``session.file.get_stream`` on the client.
+    """
+    if not paths:
+        return []
+
+    import polars as pl
+
+    if is_sproc:
+        from snowflake.snowpark.files import SnowflakeFile
+
+        def opener(p: str):
+            return SnowflakeFile.open(p, "rb", require_scoped_url=False)
+
+    else:
+        opener = session.file.get_stream
+
+    def _work(p: str):
+        with opener(p) as f:
+            return pl.read_parquet(f)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as ex:
+        return list(ex.map(_work, paths))
+
+
+def _copy_df_to_stage(
+    df: DataFrame,
+    sub_prefix: str,
+    statement_params: dict[str, str] | None = None,
+) -> list[str]:
+    """COPY INTO the session stage as Parquet and return the staged file paths.
+
+    Uses ``DataFrame.write.copy_into_location`` so plan compilation and
+    statement params go through the same path as other write actions. No
+    pre-sort is applied — callers wanting row-group elimination should
+    ``.sort(...)`` before ``to_polars``.
+    """
+    rid = uuid.uuid4().hex[:12]
+    stage = df._session.get_session_stage().rstrip("/")
+    sub = f"{stage}/{sub_prefix}/{rid}/"
+    df.write.copy_into_location(
+        sub,
+        file_format_type="parquet",
+        format_type_options={"COMPRESSION": "SNAPPY"},
+        header=True,
+        overwrite=True,
+        statement_params=statement_params,
+    )
+    rows = df._session.sql(f"LIST '{sub}'").collect(statement_params=statement_params)
+    # `sub` is fully qualified; LIST returns stage-relative names. Construct fully-qualified paths.
+    return [sub + row["name"].rsplit("/", 1)[-1] for row in rows]
+
+
+def arrow_eager(
+    df: DataFrame,
+    statement_params: dict[str, str] | None = None,
+) -> pl.DataFrame:
+    """Fetch the result as Arrow batches and return a polars DataFrame.
+
+    Backs the default ``to_polars()`` path (``transport="arrow"``).
+    Preserves full Snowflake type fidelity.
+    """
+    import polars as pl
+
+    parts = [
+        pl.from_arrow(batch)
+        for batch in df.to_arrow_batches(
+            statement_params=statement_params, _emit_ast=False
+        )
+    ]
+    if not parts:
+        return _empty_frame_from_schema(df, statement_params)
+    return pl.concat(parts) if len(parts) > 1 else parts[0]
+
+
+def parquet_eager(
+    df: DataFrame,
+    is_sproc: bool = False,
+    statement_params: dict[str, str] | None = None,
+    max_workers: int | None = None,
+) -> pl.DataFrame:
+    """COPY INTO Parquet, read the staged files in parallel, return a polars DataFrame.
+
+    Backs ``to_polars(transport="parquet")``. Subject to the Parquet type-fidelity
+    caveats documented on ``DataFrame.to_polars``.
+    """
+    import polars as pl
+
+    paths = _copy_df_to_stage(df, "to_polars_parquet_eager", statement_params)
+    if not paths:
+        return _empty_frame_from_schema(df, statement_params)
+    frames = _open_stage_files_parallel(
+        df._session, paths, is_sproc, max_workers=max_workers
+    )
+    if not frames:
+        return _empty_frame_from_schema(df, statement_params)
+    return pl.concat(frames) if len(frames) > 1 else frames[0]

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/proto/generated/ast_pb2.pyi

@@ -11413,6 +11413,7 @@ class WritePandas(_message.Message):
     auto_create_table: _builtins.bool
     compression: _builtins.str
     create_temp_table: _builtins.bool
+    """Deprecated: use table_type instead."""
     on_error: _builtins.str
     overwrite: _builtins.bool
     parallel: _builtins.int
@@ -11616,6 +11617,7 @@ class WriteTable(_message.Message):
     column_order: _builtins.str
     copy_grants: _builtins.bool
     create_temp_table: _builtins.bool
+    """Deprecated: use table_type instead."""
     table_type: _builtins.str
     @_builtins.property
     def change_tracking(self) -> _wrappers_pb2.BoolValue: ...

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/type_utils.py

@@ -822,6 +822,10 @@ def python_type_str_to_object(
         return datetime.time
     elif tp_str == "datetime":
         return datetime.datetime
+    elif tp_str == "timedelta":
+        return datetime.timedelta
+    elif tp_str == "YearMonthInterval":
+        return YearMonthInterval
     # This check is to handle special case when stored procs are registered using
     # register_from_file where type hints are read as strings and we don't know if
     # the DataFrame is a snowflake.snowpark.DataFrame or not. Here, the assumption
@@ -851,6 +855,8 @@ def python_type_to_snow_type(
 
     if tp is decimal.Decimal:
         return DecimalType(38, 18), False
+    elif tp is datetime.timedelta:
+        return DayTimeIntervalType(), False
     elif tp in PYTHON_TO_SNOW_TYPE_MAPPINGS:
         return PYTHON_TO_SNOW_TYPE_MAPPINGS[tp](), False
 

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/udf_utils.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
 import collections.abc
+import datetime
 import inspect
 import io
 import os
@@ -31,7 +32,11 @@ from packaging.requirements import Requirement
 import snowflake.snowpark
 from snowflake.connector.options import installed_pandas, pandas
 from snowflake.snowpark._internal import code_generation, type_utils
-from snowflake.snowpark._internal.analyzer.datatype_mapper import to_sql, to_sql_no_cast
+from snowflake.snowpark._internal.analyzer.datatype_mapper import (
+    to_sql,
+    to_sql_for_default_arg,
+    to_sql_no_cast,
+)
 from snowflake.snowpark._internal.telemetry import TelemetryField
 from snowflake.snowpark._internal.type_utils import (
     NoneType,
@@ -57,7 +62,12 @@ from snowflake.snowpark._internal.utils import (
     validate_object_name,
     warning,
 )
-from snowflake.snowpark.types import DataType, StructField, StructType
+from snowflake.snowpark.types import (
+    DataType,
+    DayTimeIntervalType,
+    StructField,
+    StructType,
+)
 from snowflake.snowpark.version import VERSION
 from snowflake.snowpark.context import (
     _ANACONDA_SHARED_REPOSITORY,
@@ -442,7 +452,7 @@ def get_opt_arg_defaults(
 
         if num_optional_args != 0:
             default_values_to_sql_str = [
-                to_sql(value, datatype)
+                to_sql_for_default_arg(value, datatype)
                 for value, datatype in zip(default_values, input_types_for_default_args)
             ]
         else:
@@ -1728,6 +1738,8 @@ def generate_call_python_sp_sql(
             sql_args.append(session._analyzer.analyze(arg._expression, {}))
         elif "system$" in sproc_name.lower():
             sql_args.append(to_sql_no_cast(arg, infer_type(arg)))
+        elif isinstance(arg, datetime.timedelta):
+            sql_args.append(to_sql(arg, DayTimeIntervalType()))
         else:
             sql_args.append(to_sql(arg, infer_type(arg)))
     return f"CALL {sproc_name}({', '.join(sql_args)})"

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/utils.py

@@ -2255,7 +2255,7 @@ class TimeTravelConfig(NamedTuple):
 
 
 class IcebergChangesConfig(NamedTuple):
-    """Configuration for Iceberg incremental reads via Snowflake ``CHANGES``.
+    """Configuration for Iceberg incremental reads via ``SPARK_INCREMENTAL_READ``.
 
     Spark Iceberg exposes incremental reads through::
 
@@ -2266,14 +2266,12 @@ class IcebergChangesConfig(NamedTuple):
 
     Snowflake translates this to::
 
-        SELECT * FROM table
-          CHANGES (INFORMATION => APPEND_ONLY)
-          AT (VERSION => S1)
-          [ END (VERSION => S2) ]
+        SELECT * FROM TABLE(
+            SPARK_INCREMENTAL_READ('<table>', S1 [, S2])
+        )
 
-    When ``end_version`` is omitted, Snowflake uses the current snapshot as
-    the end of the change interval (same semantics as omitting ``END`` on
-    generic ``CHANGES`` queries).
+    When ``end_version`` is omitted, the third argument is omitted and
+    Snowflake reads append-only changes through the current snapshot.
     """
 
     start_version: int
@@ -2327,14 +2325,24 @@ class IcebergChangesConfig(NamedTuple):
             start_version=start, end_version=end, information=info
         )
 
-    def generate_sql_clause(self) -> str:
-        clause = (
-            f" CHANGES (INFORMATION => {self.information}) "
-            f"AT (VERSION => {self.start_version})"
-        )
+    def generate_table_reference(self, table_name: str) -> str:
+        """Return a ``TABLE(SPARK_INCREMENTAL_READ(...))`` source for *table_name*.
+
+        ``SPARK_INCREMENTAL_READ`` takes the table as its first **VARCHAR**
+        argument (not a SQL identifier), so we quote *table_name* with
+        :func:`~snowflake.snowpark._internal.analyzer.datatype_mapper.str_to_sql`.
+        The string is passed through unchanged from the Spark read path
+        (``session.table(...)`` / ``DataFrameReader.load(...)``); callers that
+        need a catalog-linked or multi-part name should supply the same FQN
+        they would use in a ``CHANGES`` read (e.g. ``db.schema.table``).
+        Snowflake resolves partial names inside the TVF using session context.
+        """
+        from snowflake.snowpark._internal.analyzer.datatype_mapper import str_to_sql
+
+        args = f"{str_to_sql(table_name)}, {self.start_version}"
         if self.end_version is not None:
-            clause += f" END (VERSION => {self.end_version})"
-        return clause
+            args += f", {self.end_version}"
+        return f"TABLE(SPARK_INCREMENTAL_READ({args}))"
 
 
 def get_line_numbers(

{snowflake_snowpark_python-1.54.0 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/dataframe.py

@@ -8,6 +8,7 @@ import datetime
 import itertools
 import random
 import re
+import typing
 from collections import Counter
 from decimal import Decimal
 from functools import cached_property, reduce
@@ -161,6 +162,7 @@ from snowflake.snowpark._internal.utils import (
     experimental,
     generate_random_alphanumeric,
     get_copy_into_table_options,
+    is_in_stored_procedure,
     is_snowflake_quoted_id_case_insensitive,
     is_snowflake_unquoted_suffix_case_insensitive,
     is_sql_select_statement,
@@ -238,6 +240,7 @@ from collections.abc import Iterable
 
 if TYPE_CHECKING:
     import modin.pandas  # pragma: no cover
+    import polars  # pragma: no cover
     from table import Table  # pragma: no cover
 
 _logger = getLogger(__name__)
@@ -1371,6 +1374,117 @@ class DataFrame:
             **kwargs,
         )
 
+    @experimental(version="1.55.0")
+    @df_collect_api_telemetry
+    @publicapi
+    def to_polars(
+        self,
+        *,
+        transport: typing.Literal["arrow", "parquet"] = "arrow",
+        max_workers: Optional[int] = None,
+        statement_params: Optional[Dict[str, str]] = None,
+    ) -> "polars.DataFrame":
+        """
+        Executes the query representing this DataFrame and returns the result
+        as a `Polars DataFrame <https://docs.pola.rs/py-polars/html/reference/dataframe/index.html>`_.
+
+        The transport is selected by ``transport``:
+
+        ==========  ============================================
+        transport   Description
+        ==========  ============================================
+        "arrow"     Arrow (default; full Snowflake type fidelity)
+        "parquet"   Parquet unload + eager parallel read
+        ==========  ============================================
+
+        Usage Notes:
+            - **Transport selection**:
+                - ``"parquet"``:
+                  Recommended when the result set is large and the type-fidelity
+                  caveats are acceptable. Snowflake's ``COPY INTO`` splits the
+                  result into multiple Parquet files that are opened and read
+                  concurrently. In server-side environments such as stored
+                  procedures, each file open is a parallelizable I/O operation,
+                  so the concurrent access substantially reduces wall-clock time
+                  compared to the Arrow path. On a local client, connection
+                  bandwidth is the primary constraint, and the benefit is more
+                  modest; for small or medium result sets the ``COPY INTO``
+                  setup cost may outweigh the gain, making Arrow the more
+                  efficient choice.
+                - ``"arrow"`` (default):
+                  Streams result batches directly from the cursor without
+                  staging to disk. Preserves full Snowflake type fidelity.
+                  Use when type accuracy is required, or when the result set is
+                  small enough that the Parquet path's ``COPY INTO`` overhead
+                  is not justified.
+            - **Parallelism tuning**: ``max_workers`` controls the thread pool
+              for opening and reading staged Parquet files. Only applies to
+              the ``"parquet"`` transport; ignored for ``"arrow"``. The default
+              (``None``) defers to
+              :class:`~concurrent.futures.ThreadPoolExecutor`.
+
+        Example::
+
+            >>> df = session.create_dataframe([[1, 2], [3, 4]], schema=["a", "b"])
+            >>> df.to_polars().shape  # doctest: +SKIP
+            (2, 2)
+
+        Args:
+            transport: Either ``"arrow"`` (default) or ``"parquet"``. When
+                ``"parquet"``, unload the result to Parquet on the session
+                stage and read the files back in parallel. Can be faster than
+                the ``"arrow"`` transport for large, data-transfer-dominated
+                workloads — especially in a stored procedure — but subject to
+                the type-fidelity limits below.
+            max_workers: Maximum number of threads for parallel stage-file
+                opens and reads. Only applies to the ``"parquet"`` transport
+                (``transport="parquet"``). Defaults to ``None``.
+            statement_params: Dictionary of statement level parameters to be
+                set while executing this action.
+
+        Note:
+            1. Requires ``polars>=1.0``.
+
+            2. The ``"parquet"`` transport
+            does not fully preserve Snowflake types because ``COPY INTO``
+            has restrictions on Parquet unload:
+
+               - ``TIMESTAMP_LTZ`` and ``TIMESTAMP_TZ`` columns cause the
+                 unload to error.
+               - ``TIMESTAMP_NTZ`` values with nanosecond precision are
+                 truncated to milliseconds.
+               - ``FLOAT`` (double) columns are downcast to ``float32``.
+
+            See the `COPY INTO <location> usage notes
+            <https://docs.snowflake.com/en/sql-reference/sql/copy-into-location#usage-notes>`_
+            for the full unload type mapping. Use the Arrow default when
+            full type fidelity is required.
+        """
+        from snowflake.snowpark._internal.polars_backend import (
+            arrow_eager as _arrow_eager,
+            parquet_eager as _parquet_eager,
+        )
+
+        is_sproc = is_in_stored_procedure()
+        normalized_transport = transport.strip().lower()
+
+        if normalized_transport == "parquet":
+            return _parquet_eager(
+                self,
+                is_sproc=is_sproc,
+                statement_params=statement_params,
+                max_workers=max_workers,
+            )
+        elif normalized_transport == "arrow":
+            return _arrow_eager(
+                self,
+                statement_params=statement_params,
+            )
+        raise ValueError(
+            f"Unsupported transport {transport!r} for to_polars(). "
+            'Expected "arrow" or "parquet".'
+        )
+
     @df_api_usage
     @publicapi
     def to_df(
@@ -6512,7 +6626,7 @@ class DataFrame:
             ast_id = self._ast_id
             self._ast_id = None  # set the AST ID to None to prevent AST emission.
             self.write.save_as_table(
-                temp_table_name, create_temp_table=True, _emit_ast=False
+                temp_table_name, table_type="temp", _emit_ast=False
             )
             self._ast_id = ast_id  # restore the original AST ID.
         else: