snowflake-snowpark-python 1.49.0__tar.gz → 1.50.0__tar.gz

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Release History
 
+## 1.50.0 (2026-04-23)
+
+### Snowpark Python API Updates
+
+#### New Features
+
+- Added `artifact_repository` support to `udtf_configs` in `session.read.dbapi()`, enabling users to specify a custom artifact repository (e.g. PyPI) for packages used by the internal UDTF during distributed ingestion.
+
+#### Bug Fixes
+
+- Fixed a bug where `TRY_CAST` reader option is ignored when calling `DataFrameReader.schema().csv()`.
+- Fixed a bug where `event_table_telemetry` is using incorrect resource attributes.
+- Fixed a bug where `value_contains_null` was not propagated for `MapType` in `_as_nested` function.
+- Fixed a bug where CTE optimization incorrectly deduplicated subtrees containing non-deterministic data generation functions (e.g. `uuid_string()`). 
+- Fixed a bug where vectorized UDFs using non-anaconda package repositories did not specify the pandas package by default.
+
+### Snowpark pandas API Updates
+
+#### Dependency Updates
+
+- Updated the supported `pandas` versions to <=2.4 (was previously <=2.3.1).
+
 ## 1.49.0 (2026-04-13)
 
 ### Snowpark Python API Updates

{snowflake_snowpark_python-1.49.0/src/snowflake_snowpark_python.egg-info → snowflake_snowpark_python-1.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-snowpark-python
-Version: 1.49.0
+Version: 1.50.0
 Summary: Snowflake Snowpark for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -50,7 +50,7 @@ Requires-Dist: snowflake-connector-python[pandas]<5.0.0,>=3.17.0; extra == "pand
 Provides-Extra: modin
 Requires-Dist: snowflake-connector-python[pandas]<5.0.0,>=3.17.0; extra == "modin"
 Requires-Dist: modin<0.38.0,>=0.36.0; extra == "modin"
-Requires-Dist: pandas<=2.3.1; extra == "modin"
+Requires-Dist: pandas<=2.4; extra == "modin"
 Requires-Dist: tqdm; extra == "modin"
 Requires-Dist: ipywidgets; extra == "modin"
 Provides-Extra: secure-local-storage
@@ -74,10 +74,11 @@ Requires-Dist: tox; extra == "development"
 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"
 Provides-Extra: modin-development
 Requires-Dist: snowflake-connector-python[pandas]<5.0.0,>=3.17.0; extra == "modin-development"
 Requires-Dist: modin<0.38.0,>=0.36.0; extra == "modin-development"
-Requires-Dist: pandas<=2.3.1; extra == "modin-development"
+Requires-Dist: pandas<=2.4; extra == "modin-development"
 Requires-Dist: tqdm; extra == "modin-development"
 Requires-Dist: ipywidgets; extra == "modin-development"
 Requires-Dist: pytest<8.0.0; extra == "modin-development"
@@ -98,6 +99,7 @@ Requires-Dist: tox; extra == "modin-development"
 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: scipy<=1.16.3; extra == "modin-development"
 Requires-Dist: statsmodels; extra == "modin-development"
 Requires-Dist: scikit-learn; extra == "modin-development"

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/setup.py

@@ -43,7 +43,7 @@ PANDAS_REQUIREMENTS = [
 MODIN_REQUIREMENTS = [
     *PANDAS_REQUIREMENTS,
     f"modin{MODIN_DEPENDENCY_VERSION}",
-    "pandas<=2.3.1",
+    "pandas<=2.4",
     "tqdm",  # For progress bars during backend switching
     "ipywidgets",  # For enhanced progress bars in Jupyter notebooks
 ]
@@ -66,6 +66,7 @@ DEVELOPMENT_REQUIREMENTS = [
     "snowflake.core>=1.0.0, <2",  # Catalog
     "psutil",  # testing for telemetry
     "lxml",  # used in XML reader unit tests
+    "pyarrow",  # used in dataframe reader tests
 ]
 MODIN_DEVELOPMENT_REQUIREMENTS = [
     # Snowpark pandas 3rd party library testing. Cap the scipy version because

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/src/snowflake/snowpark/_internal/analyzer/datatype_mapper.py

@@ -401,6 +401,16 @@ def to_sql(
             else str_to_sql(value)
         )
 
+    if isinstance(datatype, StringType) and isinstance(
+        value, (bool, int, float, Decimal)
+    ):
+        # Coerce common Python scalars to str so that VALUES and bind-param
+        # paths produce identical string representations.  bool is a subclass
+        # of int so it must be checked first.  Use lowercase for bools to
+        # match Snowflake's BOOLEAN::STRING cast semantics.
+        s = str(value).lower() if isinstance(value, bool) else str(value)
+        return to_sql(s, datatype, from_values_statement=from_values_statement)
+
     if isinstance(datatype, _IntegralType):
         return f"{value} :: INT"
 

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/src/snowflake/snowpark/_internal/analyzer/select_statement.py

@@ -4,11 +4,12 @@
 
 import sys
 import uuid
+import re
 from abc import ABC, abstractmethod
 from collections import UserDict, defaultdict
 from copy import copy, deepcopy
 from enum import Enum
-from functools import reduce
+from functools import cached_property, reduce
 from typing import (
     TYPE_CHECKING,
     AbstractSet,
@@ -20,6 +21,7 @@ from typing import (
     Sequence,
     Set,
     Union,
+    Literal,
 )
 
 import snowflake.snowpark._internal.utils
@@ -86,6 +88,7 @@ from snowflake.snowpark._internal.utils import (
     is_sql_select_statement,
     ExprAliasUpdateDict,
 )
+import snowflake.snowpark.context as context
 
 # Python 3.8 needs to use typing.Iterable because collections.abc.Iterable is not subscriptable
 # Python 3.9 can use both
@@ -109,6 +112,22 @@ SEQUENCE_DEPENDENT_DATA_GENERATION = (
     "seq8",
 )
 
+# Functions that are non-deterministic when called with zero arguments.
+# Used only by the CTE optimizer to prevent deduplication of subtrees that
+# generate random data.  Other data generation functions (normal, zipf,
+# uniform, randstr) always require a generator argument (e.g. random()),
+# which is caught by recursive child inspection.  seq* functions produce
+# deterministic row-local counters and are safe to dedup.
+NONDETERMINISTIC_DATA_GENERATION = (
+    "uuid_string",
+    "random",
+)
+# Matches zero-arg calls to nondeterministic functions in SQL text, e.g. "random()" or "UUID_STRING( )".
+NONDETERMINISTIC_ZERO_ARG_RE = re.compile(
+    r"\b(?:" + "|".join(NONDETERMINISTIC_DATA_GENERATION) + r")\s*\(\s*\)",
+    re.IGNORECASE,
+)
+
 
 class ColumnChangeState(Enum):
     """The change state of a column when building a query from its subquery."""
@@ -995,6 +1014,21 @@ class SelectStatement(Selectable):
         )
         return copied
 
+    @cached_property
+    def contains_data_generation(self) -> bool:
+        """True when this node's projection, where, or order_by clauses
+        contain non-deterministic data-generation expressions (e.g. zero-arg
+        ``uuid_string()``, ``random()``, ``uniform(1,100,random())``).
+        limit and offset do not accept data generation expressions in snowflake.
+        """
+        return (
+            has_nondeterministic_data_generation_exp(self.projection)
+            or has_nondeterministic_data_generation_exp(
+                [self.where] if self.where else None
+            )
+            or has_nondeterministic_data_generation_exp(self.order_by)
+        )
+
     @property
     def column_states(self) -> ColumnStateDict:
         if self._column_states is None:
@@ -1386,9 +1420,9 @@ class SelectStatement(Selectable):
         ):
             # TODO: Clean up, this entire if case is parameter protection
             can_be_flattened = False
-        elif (self.where or self.order_by or self.limit_) and has_data_generator_exp(
-            cols
-        ):
+        elif (
+            self.where or self.order_by or self.limit_
+        ) and has_data_generator_or_window_function_exp(cols):
             can_be_flattened = False
         elif self.where and (
             (subquery_dependent_columns := derive_dependent_columns(self.where))
@@ -1399,6 +1433,23 @@ class SelectStatement(Selectable):
                     subquery_dependent_columns & new_column_states.active_columns
                 )
             )
+            or (
+                # unflattenable condition: dropped column is used in subquery WHERE clause and dropped column status is NEW or CHANGED in the subquery
+                # reason: we should not flatten because the dropped column is not available in the new query, leading to WHERE clause error
+                # sample query: 'select "b" from (select "a" as "c", "b" from table where "c" > 1)' can not be flatten to 'select "b" from table where "c" > 1'
+                (
+                    context._is_snowpark_connect_compatible_mode
+                    and context._snowpark_connect_flatten_select_after_sort
+                )
+                and new_column_states.dropped_columns
+                and any(
+                    self.column_states[_col].change_state
+                    in (ColumnChangeState.NEW, ColumnChangeState.CHANGED_EXP)
+                    for _col in (
+                        subquery_dependent_columns & new_column_states.dropped_columns
+                    )
+                )
+            )
         ):
             can_be_flattened = False
         elif self.order_by and (
@@ -1411,6 +1462,23 @@ class SelectStatement(Selectable):
                     subquery_dependent_columns & new_column_states.active_columns
                 )
             )
+            or (
+                # unflattenable condition: dropped column is used in subquery ORDER BY clause and dropped column status is NEW or CHANGED in the subquery
+                # reason: we should not flatten because the dropped column is not available in the new query, leading to ORDER BY clause error
+                # sample query: 'select "b" from (select "a" as "c", "b" order by "c")' can not be flatten to 'select "b" from table order by "c"'
+                (
+                    context._is_snowpark_connect_compatible_mode
+                    and context._snowpark_connect_flatten_select_after_sort
+                )
+                and new_column_states.dropped_columns
+                and any(
+                    self.column_states[_col].change_state
+                    in (ColumnChangeState.NEW, ColumnChangeState.CHANGED_EXP)
+                    for _col in (
+                        subquery_dependent_columns & new_column_states.dropped_columns
+                    )
+                )
+            )
         ):
             can_be_flattened = False
         elif self.distinct_:
@@ -1456,8 +1524,62 @@ class SelectStatement(Selectable):
                 self.df_ast_ids.copy() if self.df_ast_ids is not None else None
             )
         else:
+            new_order_by = None
+            new_from = self
+            if (
+                context._is_snowpark_connect_compatible_mode
+                and context._snowpark_connect_flatten_select_after_sort
+            ) and self.order_by:
+                order_by_dependent_columns = derive_dependent_columns(*self.order_by)
+                if order_by_dependent_columns in (
+                    COLUMN_DEPENDENCY_DOLLAR,
+                    COLUMN_DEPENDENCY_ALL,
+                ):
+                    new_order_by = None
+                elif any(
+                    col not in self.from_.column_states
+                    and col not in self.column_states
+                    for col in order_by_dependent_columns
+                ):
+                    new_order_by = None
+                elif any(
+                    _col not in self.column_states
+                    or self.column_states[_col].change_state
+                    in (ColumnChangeState.CHANGED_EXP, ColumnChangeState.DROPPED)
+                    for _col in order_by_dependent_columns
+                ):
+                    new_from = copy(self)
+                    missing_columns = (
+                        order_by_dependent_columns
+                        - new_from.column_states.active_columns
+                    )
+                    base_projection: List[Expression] = (
+                        new_from.projection
+                        if new_from.projection is not None
+                        else list(new_from.column_states.projection)
+                    )
+                    new_from.projection = base_projection + [
+                        Attribute(col, DataType()) for col in missing_columns
+                    ]
+                    new_col_states = derive_column_states_from_subquery(
+                        new_from.projection, new_from.from_
+                    )
+                    if new_col_states is not None:
+                        new_from.column_states = new_col_states
+                        new_from._projection_in_str = None
+                        new_from._commented_sql = None
+                        new_from._sql_query = None
+                        new_order_by = self.order_by
+                    else:
+                        new_from = self
+                        new_order_by = None
+                else:
+                    new_order_by = self.order_by
             new = SelectStatement(
-                projection=cols, from_=self.to_subqueryable(), analyzer=self.analyzer
+                projection=cols,
+                from_=new_from.to_subqueryable(),
+                order_by=new_order_by,
+                analyzer=self.analyzer,
             )
             new._merge_projection_complexity_with_subquery = (
                 can_select_projection_complexity_be_merged(
@@ -1478,12 +1600,30 @@ class SelectStatement(Selectable):
         return new
 
     def filter(self, col: Expression) -> "SelectStatement":
+        self._session._retrieve_aggregation_function_list()
         can_be_flattened = (
             (not self.flatten_disabled)
             and can_clause_dependent_columns_flatten(
-                derive_dependent_columns(col), self.column_states
+                derive_dependent_columns(col),
+                self.column_states,
+                "filter",
+                # In Snowpark Connect compatible mode, the NEW-column branch
+                # below allows flattening through any subquery. Pass
+                # subquery_has_limit so that branch can still reject
+                # flattening across LIMIT/OFFSET, since WHERE cannot cross
+                # LIMIT/OFFSET without changing semantics.
+                subquery_has_limit_or_offset=(
+                    self.limit_ is not None or self.offset is not None
+                ),
             )
-            and not has_data_generator_exp(self.projection)
+            and not has_data_generator_or_window_function_exp(self.projection)
+            and not (
+                (
+                    context._is_snowpark_connect_compatible_mode
+                    and context._snowpark_connect_flatten_select_after_sort
+                )
+                and has_aggregation_function_exp(self.projection)
+            )  # sum(col) as new_col, new_col can not be flattened in where clause
             and not (self.order_by and self.limit_ is not None)
         )
         if can_be_flattened:
@@ -1509,16 +1649,12 @@ class SelectStatement(Selectable):
     def sort(self, cols: List[Expression]) -> "SelectStatement":
         can_be_flattened = (
             (not self.flatten_disabled)
-            # limit order by and order by limit can cause big performance
-            # difference, because limit can stop table scanning whenever the
-            # number of record is satisfied.
-            # Therefore, disallow sql simplification when the
-            # current SelectStatement has a limit clause to avoid moving
-            # order by in front of limit.
+            # Disallow flattening when the current SelectStatement has a
+            # limit clause to avoid moving order by in front of limit.
             and (not self.limit_)
             and (not self.offset)
             and can_clause_dependent_columns_flatten(
-                derive_dependent_columns(*cols), self.column_states
+                derive_dependent_columns(*cols), self.column_states, "sort"
             )
             and not has_data_generator_exp(self.projection)
         )
@@ -1557,7 +1693,7 @@ class SelectStatement(Selectable):
             # .order_by(col1).select(col2).distinct() cannot be flattened because
             # SELECT DISTINCT B FROM TABLE ORDER BY A is not valid SQL
             and (not (self.order_by and self.has_projection))
-            and not has_data_generator_exp(self.projection)
+            and not has_data_generator_or_window_function_exp(self.projection)
         )
         if can_be_flattened:
             new = copy(self)
@@ -2048,7 +2184,13 @@ def can_projection_dependent_columns_be_flattened(
 def can_clause_dependent_columns_flatten(
     dependent_columns: Optional[AbstractSet[str]],
     subquery_column_states: ColumnStateDict,
+    clause: Literal["filter", "sort"],
+    subquery_has_limit_or_offset: bool = False,
 ) -> bool:
+    assert clause in (
+        "filter",
+        "sort",
+    ), f"Invalid clause called in can_clause_dependent_columns_flatten: {clause}"
     if dependent_columns == COLUMN_DEPENDENCY_DOLLAR:
         return False
     elif (
@@ -2063,15 +2205,39 @@ def can_clause_dependent_columns_flatten(
             dc_state = subquery_column_states.get(dc)
             if dc_state:
                 if dc_state.change_state == ColumnChangeState.CHANGED_EXP:
-                    return False
+                    if clause == "filter":
+                        return False
+                    # sort + CHANGED_EXP: safe in SCOS mode since ORDER BY
+                    # is evaluated after projection. Keep checking remaining
+                    # columns though — another column may be unsafe.
+                    elif not (
+                        context._is_snowpark_connect_compatible_mode
+                        and context._snowpark_connect_flatten_select_after_sort
+                    ):
+                        return False
                 elif dc_state.change_state == ColumnChangeState.NEW:
-                    # Most of the time this can be flattened. But if a new column uses window function and this column
-                    # is used in a clause, the sql doesn't work in Snowflake.
-                    # For instance `select a, rank() over(order by b) as d from test_table where d = 1` doesn't work.
-                    # But `select a, b as d from test_table where d = 1` works
-                    # We can inspect whether the referenced new column uses window function. Here we are being
-                    # conservative for now to not flatten the SQL.
-                    return False
+                    if clause == "sort" and dc_state.dependent_columns in (
+                        COLUMN_DEPENDENCY_DOLLAR,
+                        COLUMN_DEPENDENCY_ALL,
+                    ):
+                        # Scalar subqueries in sort can trigger Snowflake
+                        # internal errors when ORDER BY references them
+                        # at the same SELECT level.
+                        return False
+                    if not (
+                        context._is_snowpark_connect_compatible_mode
+                        and context._snowpark_connect_flatten_select_after_sort
+                    ):
+                        return False
+                    # Compatible-mode safety: even though we loosened the
+                    # NEW-column flatten rule above, we must not flatten a
+                    # WHERE across LIMIT/OFFSET on a NEW column — that
+                    # would push the filter in front of the limit and
+                    # change the result set. (Sort has its own
+                    # `not self.limit_` guard at the call site.)
+                    if clause == "filter" and subquery_has_limit_or_offset:
+                        return False
+
     return True
 
 
@@ -2295,18 +2461,139 @@ def derive_column_states_from_subquery(
     return column_states
 
 
-def has_data_generator_exp(expressions: Optional[List["Expression"]]) -> bool:
+def _check_expressions_for_types(
+    expressions: Optional[List["Expression"]],
+    check_data_gen: bool = False,
+    check_window: bool = False,
+    check_aggregation: bool = False,
+) -> bool:
+    """Efficiently check if expressions contain specific types in a single pass.
+
+    Args:
+        expressions: List of expressions to check
+        check_data_gen: Check for data generator functions
+        check_window: Check for window functions
+        check_aggregation: Check for aggregation functions
+
+    Returns:
+        True if any requested type is found
+    """
     if expressions is None:
         return False
+
     for exp in expressions:
-        if isinstance(exp, WindowExpression):
+        if exp is None:
+            continue
+
+        # Check window functions
+        if check_window and isinstance(exp, WindowExpression):
             return True
-        if isinstance(exp, FunctionExpression) and (
-            exp.is_data_generator
-            or exp.name.lower() in SEQUENCE_DEPENDENT_DATA_GENERATION
+
+        if check_data_gen:
+            if isinstance(exp, FunctionExpression) and (
+                exp.is_data_generator
+                or exp.name.lower() in SEQUENCE_DEPENDENT_DATA_GENERATION
+            ):
+                # https://docs.snowflake.com/en/sql-reference/functions-data-generation
+                return True
+
+        # Check aggregation functions
+        if check_aggregation and isinstance(exp, FunctionExpression):
+            if exp.name.lower() in context._aggregation_function_set:
+                return True
+
+        # Recursively check children.
+        # Some expression types (e.g. CaseWhen) store sub-expressions in
+        # _child_expressions rather than children; fall back to that.
+        sub_exps = exp.children
+        if not sub_exps:
+            sub_exps = getattr(exp, "_child_expressions", None)
+        if _check_expressions_for_types(
+            sub_exps, check_data_gen, check_window, check_aggregation
+        ):
+            return True
+
+    return False
+
+
+def has_data_generator_exp(expressions: Optional[List["Expression"]]) -> bool:
+    """Check if expressions contain data generator functions.
+
+    Note:
+        In non-connect mode, window expressions are also treated as data generators
+        for backward compatibility.
+    """
+    if not (
+        context._is_snowpark_connect_compatible_mode
+        and context._snowpark_connect_flatten_select_after_sort
+    ):
+        return _check_expressions_for_types(
+            expressions, check_data_gen=True, check_window=True
+        )
+    return _check_expressions_for_types(expressions, check_data_gen=True)
+
+
+def has_data_generator_or_window_function_exp(
+    expressions: Optional[List["Expression"]],
+) -> bool:
+    """Check if expressions contain data generators or window functions."""
+    return _check_expressions_for_types(
+        expressions, check_data_gen=True, check_window=True
+    )
+
+
+def has_aggregation_function_exp(expressions: Optional[List["Expression"]]) -> bool:
+    """Check if expressions contain aggregation functions."""
+    return _check_expressions_for_types(expressions, check_aggregation=True)
+
+
+def has_nondeterministic_data_generation_exp(
+    expressions: Optional[List["Expression"]],
+) -> bool:
+    """Check if expressions contain non-deterministic data generation that would
+    produce different results when materialized once via a CTE vs evaluated
+    multiple times.
+
+    This is a different check than ``has_data_generator_exp`` (which is used
+    for SQL-flattening decisions).  Here we only care about functions whose
+    output *changes across evaluations* — i.e. true randomness or
+    sequence-dependent generators invoked **without arguments** (zero-arg
+    ``random()``, ``uuid_string()``, ``randstr()``).
+
+    Generators like ``seq1(sign)``, ``uniform(lo, hi, gen)`` with explicit
+    seed, or ``uuid_string(uuid, name)`` are *not* flagged by this function
+    because CTE deduplication is safe for them.  Note that ``seq*`` functions
+    are not fully deterministic — values may have gaps and ordering is not
+    guaranteed (see https://docs.snowflake.com/en/user-guide/querying-sequences),
+    however values within a single query are always distinct.  This does not
+    affect CTE safety: the concern here is whether *re-evaluating* a subtree
+    would produce *entirely different* values (as ``random()`` or
+    ``uuid_string()`` would), not whether sequences are gap-free or ordered.
+
+    Heuristic: a ``FunctionExpression`` is flagged when:
+      - it has ``is_data_generator=True`` **and** zero arguments, OR
+      - its name is in ``NONDETERMINISTIC_DATA_GENERATION`` **and** zero
+        arguments, OR
+      - any of its *children* satisfy the above recursively (catches patterns
+        like ``uniform(1, 100, random())``).
+
+    The zero-arg gate safely distinguishes non-deterministic calls (e.g.
+    ``random()``) from deterministic ones (e.g. ``random(seed)``), because the
+    latter have ``len(children) > 0``.
+
+    Known limitations:
+      - ``session.sql(...)`` has no expression tree, so it cannot be
+        auto-detected.
+    """
+    if expressions is None:
+        return False
+    for exp in expressions:
+        if (
+            isinstance(exp, FunctionExpression)
+            and len(exp.children) == 0
+            and exp.name.lower() in NONDETERMINISTIC_DATA_GENERATION
         ):
-            # https://docs.snowflake.com/en/sql-reference/functions-data-generation
             return True
-        if exp is not None and has_data_generator_exp(exp.children):
+        if exp is not None and has_nondeterministic_data_generation_exp(exp.children):
             return True
     return False

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py

@@ -526,6 +526,14 @@ class SnowflakePlan(LogicalPlan):
         compiler = PlanCompiler(self)
         return compiler.compile()
 
+    def get_execution_queries_without_cte(self) -> Dict["PlanQueryType", List["Query"]]:
+        """Compile execution queries with CTE optimization skipped.
+        Used for retry when CTE-optimized SQL fails at the server."""
+        from snowflake.snowpark._internal.compiler.plan_compiler import PlanCompiler
+
+        compiler = PlanCompiler(self)
+        return compiler.compile(skip_cte_optimization=True)
+
     @property
     def children_plan_nodes(self) -> List[Union["Selectable", "SnowflakePlan"]]:
         """

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/src/snowflake/snowpark/_internal/compiler/cte_utils.py

@@ -105,6 +105,45 @@ def find_duplicate_subtrees(
 
         return False
 
+    def is_node_with_data_generation_exp(node: "TreeNode") -> bool:
+        """Check if a tree node contains non-deterministic data-generation
+        expressions (e.g. zero-arg ``uuid_string()``, ``random()``).
+
+        CTE deduplication must be skipped for such nodes because Snowflake
+        materializes CTEs; re-using a single CTE would repeat the same
+        generated values instead of producing fresh ones per branch.
+
+        When sql_simplifier is enabled the plan tree contains
+        SelectStatement nodes whose expression trees we can inspect
+        directly.  When it is disabled the plan tree uses generic
+        LogicalPlan nodes (Union, Project, …) that lack expression
+        metadata, so we fall back to a regex check on the resolved SQL.
+        """
+        if isinstance(node, SelectStatement) and node.contains_data_generation:
+            return True
+
+        if isinstance(node, SnowflakePlan) and isinstance(
+            node.source_plan, (SnowflakePlan, Selectable)
+        ):
+            return is_node_with_data_generation_exp(node.source_plan)
+        elif (
+            isinstance(node, SnowflakePlan)
+            and node.source_plan is not None
+            and not node.session.sql_simplifier_enabled
+        ):
+            # sql_simplifier disabled path — source_plan is a generic
+            # LogicalPlan (e.g. Union, Project) without expression trees
+            from snowflake.snowpark._internal.analyzer.select_statement import (
+                NONDETERMINISTIC_ZERO_ARG_RE,
+            )  # prevent circular import
+
+            return bool(NONDETERMINISTIC_ZERO_ARG_RE.search(node.queries[-1].sql))
+
+        if isinstance(node, SelectSnowflakePlan):
+            return is_node_with_data_generation_exp(node.snowflake_plan)
+
+        return False
+
     def traverse(root: "TreeNode") -> None:
         """
         This function uses an iterative approach to avoid hitting Python's maximum recursion depth limit.
@@ -117,7 +156,9 @@ def find_duplicate_subtrees(
             for node in current_level:
                 id_node_map[node.encoded_node_id_with_query].append(node)
 
-                if is_select_from_file_node(node):
+                if is_select_from_file_node(node) or is_node_with_data_generation_exp(
+                    node
+                ):
                     invalid_ids_for_deduplication.add(node.encoded_node_id_with_query)
 
                 for child in node.children_plan_nodes:

{snowflake_snowpark_python-1.49.0 → snowflake_snowpark_python-1.50.0}/src/snowflake/snowpark/_internal/compiler/plan_compiler.py

@@ -78,7 +78,9 @@ class PlanCompiler:
             )
         )
 
-    def compile(self) -> Dict[PlanQueryType, List[Query]]:
+    def compile(
+        self, *, skip_cte_optimization: bool = False
+    ) -> Dict[PlanQueryType, List[Query]]:
         # initialize the queries with the original queries without optimization
         final_plan = self._plan
         queries = {
@@ -107,7 +109,10 @@ class PlanCompiler:
                     # 3. apply each optimizations if needed
                     # CTE optimization
                     with measure_time() as cte_time:
-                        if session.cte_optimization_enabled:
+                        if (
+                            session.cte_optimization_enabled
+                            and not skip_cte_optimization
+                        ):
                             repeated_subquery_eliminator = RepeatedSubqueryElimination(
                                 logical_plans, query_generator
                             )