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

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

@@ -1,5 +1,56 @@
 # 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
+
+#### New Features
+
+- Added `ai_count_tokens` function to `snowflake.snowpark.functions` to estimate token counts for AI function calls.
+- Added `ai_multi_embed` function to `snowflake.snowpark.functions` to generate multimodal embeddings from text, images, audio, or video files.
+- Added `ai_redact` function to `snowflake.snowpark.functions` to detect and redact personally identifiable information (PII) from text.
+- Added `DataFrame.ai.multi_embed` method to generate multimodal embeddings via the DataFrame API.
+- Added `DataFrame.ai.redact` method to detect and redact PII from text columns via the DataFrame API.
+- Added `DataFrame.ai.translate` method to translate text columns between languages via the DataFrame API.
+
+#### Improvements
+
+- Removed the `experimental` tag from all AI SQL functions in `DataFrameAIFunctions` (`complete`, `filter`, `agg`, `classify`, `similarity`, `sentiment`, `embed`, `summarize_agg`, `transcribe`, `parse_document`, `extract`, `count_tokens`, `split_text_markdown_header`, `split_text_recursive_character`) and `RelationalGroupedDataFrame.ai_agg`.
+- Updated `DataFrame.ai.count_tokens` to match the standalone `ai_count_tokens` function: `function_name` is now the required first parameter, and `model` is optional. Also added `options` and `return_error_details` parameters.
+
+#### Bug Fixes
+
+- Fixed `DataFrame.ai.count_tokens` to call the `AI_COUNT_TOKENS` SQL function instead of the deprecated `SNOWFLAKE.CORTEX.COUNT_TOKENS`. Token counts may differ slightly due to the updated tokenizer.
+- Reverted the change introduced in 1.53.0 to eliminate unnecessary `SELECT *` from joins, which was causing performance regressions. This has no functional impact.
+
 ## 1.53.1 (2026-07-14)
 
 No user-facing changes in this release.
@@ -23,6 +74,10 @@ No user-facing changes in this release.
 - Fixed a bug where single quotes and backslashes in `comment` (`create_or_replace_view` / dynamic table / `save_as_table`), collation specs (`Column.collate`), VARIANT/OBJECT subfield keys (`Column[...]`), and `DataFrame`/`Session.flatten` paths were not correctly escaped when generating SQL, which could produce malformed statements. Backslash sequences (e.g. `\t`, `\n`) in these values are now applied literally rather than interpreted.
 - Fixed a bug where string values in the AI functions (`ai_extract`, `ai_classify`, `ai_similarity`, `ai_parse_document`, `ai_transcribe`, `ai_complete`) configuration and `response_format` were not correctly escaped when generating the SQL object literal, which could produce malformed statements when a value contained single quotes or backslashes (for example, an apostrophe in a natural-language question).
 
+#### Improvements
+
+- Reduced the size of generated query text for repeated join operations.
+
 #### Dependency Updates
 
 - Lifted `protobuf` restriction for Python 3.14 from `==5.29.3` to `>=5.29.3,<6.34`.
@@ -45,7 +100,6 @@ No user-facing changes in this release.
 #### Improvements
 
 - Improved CTE optimization to deduplicate identical subtrees in self-joins, which were previously emitted as repeated subqueries.
-- Reduced the size of generated query text for repeated join operations.
 
 #### Deprecations
 

{snowflake_snowpark_python-1.53.1/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.53.1
+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.53.1 → 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.53.1 → 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
@@ -990,33 +1015,6 @@ def lateral_join_statement(
     )
 
 
-_SELECT_STAR_FROM_PREFIX = SELECT + STAR + NEW_LINE + FROM + LEFT_PARENTHESIS + NEW_LINE
-_SELECT_STAR_FROM_SUFFIX = NEW_LINE + RIGHT_PARENTHESIS
-
-
-def _unwrap_select_star_from(sql: str) -> Optional[str]:
-    """If sql is a join-produced `SELECT * FROM (\n<join_source>\n)` (the
-    output of project_statement([], join_source)), return <join_source>.
-    Only unwraps when the inner content starts with '(' (possibly preceded
-    by UUID trace comments) which indicates a parenthesized join operand
-    rather than a wrapped SELECT statement."""
-    if sql.startswith(_SELECT_STAR_FROM_PREFIX) and sql.endswith(
-        _SELECT_STAR_FROM_SUFFIX
-    ):
-        inner = sql[len(_SELECT_STAR_FROM_PREFIX) : -len(_SELECT_STAR_FROM_SUFFIX)]
-        # In trace-SQL mode, UUID comments (\n-- <uuid>\n) may precede the
-        # opening parenthesis. Strip them before checking.
-        check = inner.lstrip("\n")
-        if check.startswith("--"):
-            # Skip the comment line and any trailing newline
-            newline_pos = check.find("\n")
-            if newline_pos != -1:
-                check = check[newline_pos + 1 :]
-        if check.startswith(LEFT_PARENTHESIS) or inner.startswith(LEFT_PARENTHESIS):
-            return inner
-    return None
-
-
 def snowflake_supported_join_statement(
     left: str,
     right: str,
@@ -1027,30 +1025,17 @@ def snowflake_supported_join_statement(
     left_uuid: Optional[str] = None,
     right_uuid: Optional[str] = None,
     directed: bool = False,
-    left_is_join: bool = False,
 ) -> str:
     LEFT_UUID = format_uuid(left_uuid)
     RIGHT_UUID = format_uuid(right_uuid)
-
-    # If left is the output of a previous join, flatten into a multi-way join
-    # by unwrapping the SELECT * FROM (...) envelope and appending the new
-    # right operand directly to the existing join source. This avoids nested
-    # SELECT * layers that inflate query text without changing semantics.
-    #
-    # Though it is technically less efficient than constructing the join sub-queries
-    # without the SELECT in the first place, the structure of our SQL processing code
-    # needs top-level projections to be wrapped by a select to be well-formed, so we
-    # must strip it here instead.
-    #
-    # We only unwrap the left side because it is simpler to deal with than unwrapping
-    # both left and right, and left-deep chains are more common, as they're produced
-    # by calls like df1.join(df2).join(df3) etc.
-    unwrapped_left = _unwrap_select_star_from(left) if left_is_join else None
+    left_alias = (
+        "SNOWPARK_LEFT"
+        if use_constant_subquery_alias
+        else random_name_for_temp_object(TempObjectType.TABLE)
+    )
     right_alias = (
         "SNOWPARK_RIGHT"
-        if use_constant_subquery_alias and unwrapped_left is None
-        # Multi-way join: right alias must be unique to avoid collisions
-        # with aliases already present in the flattened join source.
+        if use_constant_subquery_alias
         else random_name_for_temp_object(TempObjectType.TABLE)
     )
 
@@ -1086,31 +1071,18 @@ def snowflake_supported_join_statement(
 
     maybe_directed_sql = DIRECTED_JOIN if directed else JOIN
 
-    if unwrapped_left is not None:
-        # No need for additional parentheses around the left expression here, since it
-        # should already be parenthesized
-        left_expr = LEFT_UUID + unwrapped_left + NEW_LINE + LEFT_UUID
-    else:
-        left_alias = (
-            "SNOWPARK_LEFT"
-            if use_constant_subquery_alias
-            else random_name_for_temp_object(TempObjectType.TABLE)
-        )
-        left_expr = (
-            LEFT_PARENTHESIS
-            + NEW_LINE
-            + LEFT_UUID
-            + left
-            + NEW_LINE
-            + LEFT_UUID
-            + RIGHT_PARENTHESIS
-            + AS
-            + left_alias
-            + SPACE
-            + NEW_LINE
-        )
     source = (
-        left_expr
+        LEFT_PARENTHESIS
+        + NEW_LINE
+        + LEFT_UUID
+        + left
+        + NEW_LINE
+        + LEFT_UUID
+        + RIGHT_PARENTHESIS
+        + AS
+        + left_alias
+        + SPACE
+        + NEW_LINE
         + join_sql
         + maybe_directed_sql
         + NEW_LINE
@@ -1142,7 +1114,6 @@ def join_statement(
     left_uuid: Optional[str] = None,
     right_uuid: Optional[str] = None,
     directed: bool = False,
-    left_is_join: bool = False,
 ) -> str:
     if isinstance(join_type, (LeftSemi, LeftAnti)):
         return left_semi_or_anti_join_statement(
@@ -1170,7 +1141,6 @@ def join_statement(
         left_uuid=left_uuid,
         right_uuid=right_uuid,
         directed=directed,
-        left_is_join=left_is_join,
     )
 
 
@@ -1223,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}"
     )
 
 
@@ -1314,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.53.1 → 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.53.1 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/expression.py

@@ -295,13 +295,22 @@ class Star(Expression):
 
 class UnresolvedAttribute(Expression, NamedExpression):
     def __init__(
-        self, name: str, is_sql_text: bool = False, df_alias: Optional[str] = None
+        self,
+        name: str,
+        is_sql_text: bool = False,
+        df_alias: Optional[str] = None,
+        is_constant: bool = False,
     ) -> None:
         super().__init__()
         self.df_alias = df_alias
         self.name = name
         self.is_sql_text = is_sql_text
-        if "$" in name:
+        self.is_constant = is_constant
+        if is_constant:
+            # Constant SQL text (e.g. object/array literals) does not reference
+            # any columns from the input relation.
+            self._dependent_column_names = COLUMN_DEPENDENCY_EMPTY
+        elif "$" in name:
             # $n refers to a column by index. We don't consider column index yet.
             # even though "$" isn't necessarily used to refer to a column by index. We're conservative here.
             self._dependent_column_names = COLUMN_DEPENDENCY_DOLLAR

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

@@ -445,19 +445,6 @@ class Selectable(LogicalPlan, ABC):
                 # Add the last df ast id to the snowflake plan as the most recent
                 # dataframe operation to create this plan.
                 self._snowflake_plan.df_ast_ids = self.df_ast_ids
-            # Propagate join output flag through passthrough SelectStatements
-            # so chained joins can flatten into multi-way joins.
-            # Only SelectStatement has has_clause/has_projection; other
-            # Selectable subclasses (SelectSQL, SetStatement, etc.) skip this.
-            if (
-                isinstance(self, SelectStatement)
-                and not self.has_clause
-                and not self.has_projection
-                and isinstance(self.from_, SelectSnowflakePlan)
-            ):
-                self._snowflake_plan._is_join_output = (
-                    self.from_._snowflake_plan._is_join_output
-                )
         return self._snowflake_plan
 
     @property
@@ -605,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.53.1 → snowflake_snowpark_python-1.55.0}/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py

@@ -458,7 +458,6 @@ class SnowflakePlan(LogicalPlan):
         self.session = session
         self.source_plan = source_plan
         self.is_ddl_on_temp_object = is_ddl_on_temp_object
-        self._is_join_output = False
         # We need to copy this list since we don't want to change it for the
         # previous SnowflakePlan objects
         self.api_calls = api_calls.copy() if api_calls else []
@@ -770,7 +769,6 @@ class SnowflakePlan(LogicalPlan):
                 referenced_ctes=self.referenced_ctes,
             )
         plan.df_ast_ids = self.df_ast_ids
-        plan._is_join_output = self._is_join_output
         return plan
 
     def __deepcopy__(self, memodict={}) -> "SnowflakePlan":  # noqa: B006
@@ -810,7 +808,6 @@ class SnowflakePlan(LogicalPlan):
         if copied_source_plan:
             copied_source_plan._is_valid_for_replacement = True
         copied_plan.df_ast_ids = self.df_ast_ids
-        copied_plan._is_join_output = self._is_join_output
 
         return copied_plan
 
@@ -1070,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()
@@ -1239,8 +1238,7 @@ class SnowflakePlanBuilder:
         use_constant_subquery_alias: bool,
         directed: bool = False,
     ):
-        left_is_join = left._is_join_output
-        result = self.build_binary(
+        return self.build_binary(
             lambda x, y: join_statement(
                 x,
                 y,
@@ -1257,14 +1255,11 @@ class SnowflakePlanBuilder:
                     else None
                 ),
                 directed=directed,
-                left_is_join=left_is_join,
             ),
             left,
             right,
             source_plan,
         )
-        result._is_join_output = True
-        return result
 
     def save_as_table(
         self,
@@ -1323,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]