snowpark-connect 0.26.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

snowflake/snowpark_connect/config.py

@@ -171,9 +171,6 @@ class GlobalConfig:
         "spark.app.name": lambda session, name: setattr(
             session, "query_tag", f"Spark-Connect-App-Name={name}"
         ),
-        "snowpark.connect.udf.packages": lambda session, packages: session.add_packages(
-            *packages.strip("[] ").split(",")
-        ),
         "snowpark.connect.udf.imports": lambda session, imports: parse_imports(
             session, imports
         ),

snowflake/snowpark_connect/expression/map_expression.py

@@ -6,6 +6,7 @@ import datetime
 from collections import defaultdict
 
 import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
+from pyspark.errors.exceptions.connect import AnalysisException
 
 import snowflake.snowpark.functions as snowpark_fn
 from snowflake import snowpark
@@ -34,6 +35,7 @@ from snowflake.snowpark_connect.type_mapping import (
 from snowflake.snowpark_connect.typed_column import TypedColumn
 from snowflake.snowpark_connect.utils.context import (
     gen_sql_plan_id,
+    get_current_lambda_params,
     is_function_argument_being_resolved,
     is_lambda_being_resolved,
 )
@@ -271,6 +273,19 @@ def map_expression(
         case "unresolved_function":
             return map_func.map_unresolved_function(exp, column_mapping, typer)
         case "unresolved_named_lambda_variable":
+            # Validate that this lambda variable is in scope
+            var_name = exp.unresolved_named_lambda_variable.name_parts[0]
+            current_params = get_current_lambda_params()
+
+            if current_params and var_name not in current_params:
+                raise AnalysisException(
+                    f"Reference to non-lambda variable '{var_name}' within lambda function. "
+                    f"Lambda functions can only access their own parameters. "
+                    f"Available lambda parameters are: {current_params}. "
+                    f"If '{var_name}' is an outer scope lambda variable from a nested lambda, "
+                    f"that is an unsupported feature in Snowflake SQL."
+                )
+
             col = snowpark_fn.Column(
                 UnresolvedAttribute(exp.unresolved_named_lambda_variable.name_parts[0])
             )

snowflake/snowpark_connect/expression/map_unresolved_attribute.py

@@ -22,6 +22,7 @@ from snowflake.snowpark_connect.utils.context import (
     get_is_evaluating_sql,
     get_outer_dataframes,
     get_plan_id_map,
+    is_lambda_being_resolved,
     resolve_lca_alias,
 )
 from snowflake.snowpark_connect.utils.identifiers import (
@@ -356,6 +357,23 @@ def map_unresolved_attribute(
                     return (unqualified_name, typed_col)
 
         if snowpark_name is None:
+            # Check if we're inside a lambda and trying to reference an outer column
+            # This catches direct column references (not lambda variables)
+            if is_lambda_being_resolved() and column_mapping:
+                # Check if this column exists in the outer scope (not lambda params)
+                outer_col_name = (
+                    column_mapping.get_snowpark_column_name_from_spark_column_name(
+                        attr_name, allow_non_exists=True
+                    )
+                )
+                if outer_col_name:
+                    # This is an outer scope column being referenced inside a lambda
+                    raise AnalysisException(
+                        f"Reference to non-lambda variable '{attr_name}' within lambda function. "
+                        f"Lambda functions can only access their own parameters. "
+                        f"If '{attr_name}' is a table column, it must be passed as an explicit parameter to the enclosing function."
+                    )
+
             if has_plan_id:
                 raise AnalysisException(
                     f'[RESOLVED_REFERENCE_COLUMN_NOT_FOUND] The column "{attr_name}" does not exist in the target dataframe.'

snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -711,6 +711,9 @@ def map_unresolved_function(
                 "-",
             )
             match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (DateType(), NullType()) | (NullType(), DateType()):
+                    result_type = LongType()
+                    result_exp = snowpark_fn.lit(None).cast(result_type)
                 case (NullType(), _) | (_, NullType()):
                     result_type = _get_add_sub_result_type(
                         snowpark_typed_args[0].typ,
@@ -724,7 +727,10 @@ def map_unresolved_function(
                     result_type = LongType()
                     result_exp = snowpark_args[0] - snowpark_args[1]
                 case (DateType(), StringType()):
-                    if "INTERVAL" == snowpark_typed_args[1].col._expr1.pretty_name:
+                    if (
+                        hasattr(snowpark_typed_args[1].col._expr1, "pretty_name")
+                        and "INTERVAL" == snowpark_typed_args[1].col._expr1.pretty_name
+                    ):
                         result_type = TimestampType()
                         result_exp = snowpark_args[0] - snowpark_args[1]
                     else:
@@ -2421,7 +2427,7 @@ def map_unresolved_function(
                 "try_to_date",
                 snowpark_fn.cast(
                     truncated_date,
-                    TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                    TimestampType(),
                 ),
                 snowpark_args[1],
             )
@@ -8725,7 +8731,7 @@ def _resolve_function_with_lambda(
         artificial_df = Session.get_active_session().create_dataframe([], schema)
         set_schema_getter(artificial_df, lambda: schema)
 
-        with resolving_lambda_function():
+        with resolving_lambda_function(names):
             return map_expression(
                 (
                     lambda_exp.lambda_function.function
@@ -9911,7 +9917,10 @@ def _get_spark_function_name(
             return f"({date_param_name1} {operation_op} {date_param_name2})"
         case (StringType(), DateType()):
             date_param_name2 = _get_literal_param_name(exp, 1, snowpark_arg_names[1])
-            if "INTERVAL" == col1.col._expr1.pretty_name:
+            if (
+                hasattr(col1.col._expr1, "pretty_name")
+                and "INTERVAL" == col1.col._expr1.pretty_name
+            ):
                 return f"{date_param_name2} {operation_op} {snowpark_arg_names[0]}"
             elif global_config.spark_sql_ansi_enabled and function_name == "+":
                 return f"{operation_func}(cast({date_param_name2} as date), cast({snowpark_arg_names[0]} as double))"
@@ -9919,9 +9928,9 @@ def _get_spark_function_name(
                 return f"({snowpark_arg_names[0]} {operation_op} {date_param_name2})"
         case (DateType(), StringType()):
             date_param_name1 = _get_literal_param_name(exp, 0, snowpark_arg_names[0])
-            if (
-                global_config.spark_sql_ansi_enabled
-                or "INTERVAL" == col2.col._expr1.pretty_name
+            if global_config.spark_sql_ansi_enabled or (
+                hasattr(col2.col._expr1, "pretty_name")
+                and "INTERVAL" == col2.col._expr1.pretty_name
             ):
                 return f"{date_param_name1} {operation_op} {snowpark_arg_names[1]}"
             else:

snowflake/snowpark_connect/relation/map_extension.py

@@ -23,6 +23,7 @@ from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.typed_column import TypedColumn
 from snowflake.snowpark_connect.utils.context import (
     get_sql_aggregate_function_count,
+    not_resolving_fun_args,
     push_outer_dataframe,
     set_current_grouping_columns,
 )
@@ -335,14 +336,15 @@ def map_aggregate(
     typer = ExpressionTyper(input_df)
 
     def _map_column(exp: expression_proto.Expression) -> tuple[str, TypedColumn]:
-        new_names, snowpark_column = map_expression(
-            exp, input_container.column_map, typer
-        )
-        if len(new_names) != 1:
-            raise SnowparkConnectNotImplementedError(
-                "Multi-column aggregate expressions are not supported"
+        with not_resolving_fun_args():
+            new_names, snowpark_column = map_expression(
+                exp, input_container.column_map, typer
             )
-        return new_names[0], snowpark_column
+            if len(new_names) != 1:
+                raise SnowparkConnectNotImplementedError(
+                    "Multi-column aggregate expressions are not supported"
+                )
+            return new_names[0], snowpark_column
 
     raw_groupings: list[tuple[str, TypedColumn]] = []
     raw_aggregations: list[tuple[str, TypedColumn]] = []

snowflake/snowpark_connect/relation/map_map_partitions.py

@@ -8,28 +8,20 @@ from pyspark.sql.connect.proto.expressions_pb2 import CommonInlineUserDefinedFun
 import snowflake.snowpark.functions as snowpark_fn
 from snowflake import snowpark
 from snowflake.snowpark.types import StructType
-from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.constants import MAP_IN_ARROW_EVAL_TYPE
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.type_mapping import proto_to_snowpark_type
-from snowflake.snowpark_connect.utils.pandas_udtf_utils import create_pandas_udtf
-from snowflake.snowpark_connect.utils.udf_helper import (
-    SnowparkUDF,
-    process_udf_in_sproc,
-    require_creating_udf_in_sproc,
-    udf_check,
-)
-from snowflake.snowpark_connect.utils.udf_utils import (
-    ProcessCommonInlineUserDefinedFunction,
+from snowflake.snowpark_connect.utils.context import map_partitions_depth
+from snowflake.snowpark_connect.utils.pandas_udtf_utils import (
+    create_pandas_udtf,
+    create_pandas_udtf_with_arrow,
 )
+from snowflake.snowpark_connect.utils.udf_helper import udf_check
 from snowflake.snowpark_connect.utils.udtf_helper import (
     create_pandas_udtf_in_sproc,
     require_creating_udtf_in_sproc,
 )
-from snowflake.snowpark_connect.utils.udxf_import_utils import (
-    get_python_udxf_import_files,
-)
 
 
 def map_map_partitions(
@@ -41,18 +33,10 @@ def map_map_partitions(
     This is a simple wrapper around the `mapInPandas` method in Snowpark.
     """
     input_container = map_relation(rel.map_partitions.input)
-    input_df = input_container.dataframe
     udf_proto = rel.map_partitions.func
     udf_check(udf_proto)
 
-    # Check if this is mapInArrow (eval_type == 207)
-    if (
-        udf_proto.WhichOneof("function") == "python_udf"
-        and udf_proto.python_udf.eval_type == MAP_IN_ARROW_EVAL_TYPE
-    ):
-        return _map_in_arrow_with_pandas_udtf(input_container, udf_proto)
-    else:
-        return _map_partitions_with_udf(input_df, udf_proto)
+    return _map_with_pandas_udtf(input_container, udf_proto)
 
 
 def _call_udtf(
@@ -71,12 +55,17 @@ def _call_udtf(
 
     udtf_columns = input_df.columns + [snowpark_fn.col("_DUMMY_PARTITION_KEY")]
 
-    result_df_with_dummy = input_df_with_dummy.select(
-        snowpark_fn.call_table_function(udtf_name, *udtf_columns).over(
-            partition_by=[snowpark_fn.col("_DUMMY_PARTITION_KEY")]
-        )
+    tfc = snowpark_fn.call_table_function(udtf_name, *udtf_columns).over(
+        partition_by=[snowpark_fn.col("_DUMMY_PARTITION_KEY")]
     )
 
+    # Use map_partitions_depth only when mapping non nested map_partitions
+    # When mapping chained functions additional column casting is necessary
+    if map_partitions_depth() == 1:
+        result_df_with_dummy = input_df_with_dummy.join_table_function(tfc)
+    else:
+        result_df_with_dummy = input_df_with_dummy.select(tfc)
+
     output_cols = [field.name for field in return_type.fields]
 
     # Only return the output columns.
@@ -90,7 +79,7 @@ def _call_udtf(
     )
 
 
-def _map_in_arrow_with_pandas_udtf(
+def _map_with_pandas_udtf(
     input_df_container: DataFrameContainer,
     udf_proto: CommonInlineUserDefinedFunction,
 ) -> snowpark.DataFrame:
@@ -100,59 +89,29 @@ def _map_in_arrow_with_pandas_udtf(
     input_df = input_df_container.dataframe
     input_schema = input_df.schema
     spark_column_names = input_df_container.column_map.get_spark_columns()
-    return_type = proto_to_snowpark_type(udf_proto.python_udf.output_type)
+    return_type = proto_to_snowpark_type(
+        udf_proto.python_udf.output_type
+        if udf_proto.WhichOneof("function") == "python_udf"
+        else udf_proto.scalar_scala_udf.outputType
+    )
+
+    # Check if this is mapInArrow (eval_type == 207)
+    map_in_arrow = (
+        udf_proto.WhichOneof("function") == "python_udf"
+        and udf_proto.python_udf.eval_type == MAP_IN_ARROW_EVAL_TYPE
+    )
     if require_creating_udtf_in_sproc(udf_proto):
         udtf_name = create_pandas_udtf_in_sproc(
             udf_proto, spark_column_names, input_schema, return_type
         )
     else:
-        map_in_arrow_udtf = create_pandas_udtf(
-            udf_proto, spark_column_names, input_schema, return_type
-        )
-        udtf_name = map_in_arrow_udtf.name
+        if map_in_arrow:
+            map_udtf = create_pandas_udtf_with_arrow(
+                udf_proto, spark_column_names, input_schema, return_type
+            )
+        else:
+            map_udtf = create_pandas_udtf(
+                udf_proto, spark_column_names, input_schema, return_type
+            )
+        udtf_name = map_udtf.name
     return _call_udtf(udtf_name, input_df, return_type)
-
-
-def _map_partitions_with_udf(
-    input_df: snowpark.DataFrame, udf_proto
-) -> snowpark.DataFrame:
-    """
-    Original UDF-based approach for non-mapInArrow map_partitions cases.
-    """
-    input_column_names = input_df.columns
-    kwargs = {
-        "common_inline_user_defined_function": udf_proto,
-        "input_types": [f.datatype for f in input_df.schema.fields],
-        "called_from": "map_map_partitions",
-        "udf_name": "spark_map_partitions_udf",
-        "input_column_names": input_column_names,
-        "replace": True,
-        "return_type": proto_to_snowpark_type(
-            udf_proto.python_udf.output_type
-            if udf_proto.WhichOneof("function") == "python_udf"
-            else udf_proto.scalar_scala_udf.outputType
-        ),
-        "udf_packages": global_config.get("snowpark.connect.udf.packages", ""),
-        "udf_imports": get_python_udxf_import_files(input_df.session),
-    }
-
-    if require_creating_udf_in_sproc(udf_proto):
-        snowpark_udf = process_udf_in_sproc(**kwargs)
-    else:
-        udf_processor = ProcessCommonInlineUserDefinedFunction(**kwargs)
-        udf = udf_processor.create_udf()
-        snowpark_udf = SnowparkUDF(
-            name=udf.name,
-            input_types=udf._input_types,
-            return_type=udf._return_type,
-            original_return_type=None,
-        )
-    udf_column_name = "UDF_OUTPUT"
-    snowpark_columns = [snowpark_fn.col(name) for name in input_df.columns]
-    result = input_df.select(snowpark_fn.call_udf(snowpark_udf.name, *snowpark_columns))
-    return DataFrameContainer.create_with_column_mapping(
-        dataframe=result,
-        spark_column_names=[udf_column_name],
-        snowpark_column_names=[udf_column_name],
-        snowpark_column_types=[snowpark_udf.return_type],
-    )

snowflake/snowpark_connect/relation/map_relation.py

@@ -15,6 +15,7 @@ from snowflake.snowpark_connect.utils.cache import (
 from snowflake.snowpark_connect.utils.context import (
     get_plan_id_map,
     get_session_id,
+    push_map_partitions,
     push_operation_scope,
     set_is_aggregate_function,
     set_plan_id_map,
@@ -180,7 +181,8 @@ def map_relation(
                     )
                 return cached_df
             case "map_partitions":
-                result = map_map_partitions.map_map_partitions(rel)
+                with push_map_partitions():
+                    result = map_map_partitions.map_map_partitions(rel)
             case "offset":
                 result = map_row_ops.map_offset(rel)
             case "project":

snowflake/snowpark_connect/relation/map_show_string.py

@@ -12,6 +12,7 @@ from snowflake.snowpark._internal.analyzer import analyzer_utils
 from snowflake.snowpark.functions import col
 from snowflake.snowpark.types import DateType, StringType, StructField, StructType
 from snowflake.snowpark_connect.column_name_handler import set_schema_getter
+from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.map_relation import map_relation
 
@@ -33,6 +34,7 @@ def map_show_string(rel: relation_proto.Relation) -> pandas.DataFrame:
         truncate=rel.show_string.truncate,
         vertical=rel.show_string.vertical,
         _spark_column_names=input_df_container.column_map.get_spark_columns(),
+        _spark_session_tz=global_config.spark_sql_session_timeZone,
     )
     return pandas.DataFrame({"show_string": [show_string]})
 

snowflake/snowpark_connect/relation/map_sql.py

@@ -56,6 +56,7 @@ from snowflake.snowpark_connect.utils.context import (
     _accessing_temp_object,
     gen_sql_plan_id,
     get_session_id,
+    get_sql_plan,
     push_evaluating_sql_scope,
     push_sql_scope,
     set_sql_args,
@@ -542,6 +543,7 @@ def map_sql_to_pandas_df(
                 rows = session.sql(f"DESCRIBE TABLE {name}").collect()
             case "DescribeNamespace":
                 name = get_relation_identifier_name(logical_plan.namespace(), True)
+                name = change_default_to_public(name)
                 rows = session.sql(f"DESCRIBE SCHEMA {name}").collect()
                 if not rows:
                     rows = None
@@ -793,6 +795,7 @@ def map_sql_to_pandas_df(
             case "SetCatalogAndNamespace":
                 # TODO: add catalog setting here
                 name = get_relation_identifier_name(logical_plan.child(), True)
+                name = change_default_to_public(name)
                 session.sql(f"USE SCHEMA {name}").collect()
             case "SetCommand":
                 kv_result_tuple = logical_plan.kv().get()
@@ -801,6 +804,7 @@ def map_sql_to_pandas_df(
                 set_config_param(get_session_id(), key, val, session)
             case "SetNamespaceCommand":
                 name = _spark_to_snowflake(logical_plan.namespace())
+                name = change_default_to_public(name)
                 session.sql(f"USE SCHEMA {name}").collect()
             case "SetNamespaceLocation" | "SetNamespaceProperties":
                 raise SnowparkConnectNotImplementedError(
@@ -997,6 +1001,20 @@ def get_sql_passthrough() -> bool:
     return get_boolean_session_config_param("snowpark.connect.sql.passthrough")
 
 
+def change_default_to_public(name: str) -> str:
+    """
+    Change the namespace to PUBLIC when given name is DEFAULT
+    :param name: Given namespace
+    :return: if name is DEFAULT return PUBLIC otherwise name
+    """
+    if name.startswith('"'):
+        if name.upper() == '"DEFAULT"':
+            return name.replace("DEFAULT", "PUBLIC")
+    elif name.upper() == "DEFAULT":
+        return "PUBLIC"
+    return name
+
+
 def map_sql(
     rel: relation_proto.Relation,
 ) -> DataFrameContainer:
@@ -1008,7 +1026,6 @@ def map_sql(
     In passthough mode as True, SAS calls session.sql() and not calling Spark Parser.
     This is to mitigate any issue not covered by spark logical plan to protobuf conversion.
     """
-
     snowpark_connect_sql_passthrough = get_sql_passthrough()
 
     if not snowpark_connect_sql_passthrough:
@@ -1353,6 +1370,7 @@ def map_logical_plan_relation(
                     left_input=map_logical_plan_relation(children[0]),
                     right_input=map_logical_plan_relation(children[1]),
                     set_op_type=relation_proto.SetOperation.SET_OP_TYPE_UNION,
+                    is_all=True,
                     by_name=rel.byName(),
                     allow_missing_columns=rel.allowMissingCol(),
                 )
@@ -1701,7 +1719,50 @@ def map_logical_plan_relation(
                     _window_specs.get()[key] = window_spec
                 proto = map_logical_plan_relation(rel.child())
         case "Generate":
-            input_relation = map_logical_plan_relation(rel.child())
+            # Generate creates a nested Project relation (see lines 1785-1790) without
+            # setting its plan_id field. When this Project is later processed by map_project
+            # (map_column_ops.py), it uses rel.common.plan_id which defaults to 0 for unset
+            # protobuf fields. This means all columns from the Generate operation (both exploded
+            # columns and passthrough columns) will have plan_id=0 in their names.
+            #
+            # If Generate's child is a SubqueryAlias whose inner relation was processed
+            # with a non-zero plan_id, there will be a mismatch between:
+            # - The columns referenced in the Project (expecting plan_id from SubqueryAlias's child)
+            # - The actual column names created by Generate's Project (using plan_id=0)
+
+            # Therefore, when Generate has a SubqueryAlias child, we explicitly process the inner
+            # relation with plan_id=0 to match what Generate's Project will use. This only applies when
+            # the immediate child of Generate is a SubqueryAlias and preserves existing registrations (like CTEs),
+            # so it won't affect other patterns.
+
+            child_class = str(rel.child().getClass().getSimpleName())
+
+            if child_class == "SubqueryAlias":
+                alias = str(rel.child().alias())
+
+                # Check if this alias was already registered during initial SQL parsing
+                existing_plan_id = get_sql_plan(alias)
+
+                if existing_plan_id is not None:
+                    # Use the existing plan_id to maintain consistency with prior registration
+                    used_plan_id = existing_plan_id
+                else:
+                    # Use plan_id=0 to match what the nested Project will use (protobuf default)
+                    used_plan_id = 0
+                    set_sql_plan_name(alias, used_plan_id)
+
+                # Process the inner child with the determined plan_id
+                inner_child = map_logical_plan_relation(
+                    rel.child().child(), plan_id=used_plan_id
+                )
+                input_relation = relation_proto.Relation(
+                    subquery_alias=relation_proto.SubqueryAlias(
+                        input=inner_child,
+                        alias=alias,
+                    )
+                )
+            else:
+                input_relation = map_logical_plan_relation(rel.child())
             generator_output_list = as_java_list(rel.generatorOutput())
             generator_output_list_expressions = [
                 map_logical_plan_expression(e) for e in generator_output_list

snowflake/snowpark_connect/relation/write/map_write.py

@@ -51,6 +51,7 @@ from snowflake.snowpark_connect.utils.identifiers import (
     split_fully_qualified_spark_name,
 )
 from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
+from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
     telemetry,
@@ -160,6 +161,29 @@ def map_write(request: proto_base.ExecutePlanRequest):
             compression_option = write_op.options.get("compression", "none")
 
             # Generate Spark-compatible filename or prefix
+            # we need a random prefix to support "append" mode
+            # otherwise copy into with overwrite=False will fail if the file already exists
+            overwrite = (
+                write_op.mode
+                == commands_proto.WriteOperation.SaveMode.SAVE_MODE_OVERWRITE
+            )
+
+            if overwrite:
+                try:
+                    path_after_stage = (
+                        write_path.split("/", 1)[1] if "/" in write_path else ""
+                    )
+                    if not path_after_stage or path_after_stage == "/":
+                        logger.warning(
+                            f"Skipping REMOVE for root path {write_path} - too broad scope"
+                        )
+                    else:
+                        remove_command = f"REMOVE {write_path}/"
+                        session.sql(remove_command).collect()
+                        logger.info(f"Successfully cleared directory: {write_path}")
+                except Exception as e:
+                    logger.warning(f"Could not clear directory {write_path}: {e}")
+
             if should_write_to_single_file:
                 # Single file: generate complete filename with extension
                 spark_filename = generate_spark_compatible_filename(
@@ -178,10 +202,6 @@ def map_write(request: proto_base.ExecutePlanRequest):
                     format_ext="",  # No extension for prefix
                 )
                 temp_file_prefix_on_stage = f"{write_path}/{spark_filename_prefix}"
-            overwrite = (
-                write_op.mode
-                == commands_proto.WriteOperation.SaveMode.SAVE_MODE_OVERWRITE
-            )
 
             default_compression = "NONE" if write_op.source != "parquet" else "snappy"
             compression = write_op.options.get(

snowflake/snowpark_connect/server.py

@@ -531,7 +531,10 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
             if name.endswith(".class"):
                 # name is <dir>/<package>/<class_name>
                 # we don't need the dir name, but require the package, so only remove dir
-                class_files[name.split("/", 1)[-1]] = filepath
+                if os.name != "nt":
+                    class_files[name.split("/", 1)[-1]] = filepath
+                else:
+                    class_files[name.split("\\", 1)[-1]] = filepath
                 continue
             session.file.put(
                 filepath,

snowflake/snowpark_connect/utils/artifacts.py

@@ -39,7 +39,7 @@ def write_temporary_artifact(
     if os.name != "nt":
         filepath = f"/tmp/sas-{session.session_id}/{name}"
     else:
-        filepath = f"{tempfile.gettempdir()}/sas-{session.session_id}/{name}"
+        filepath = f"{tempfile.gettempdir()}\\sas-{session.session_id}\\{name}"
     # The name comes to us as a path (e.g. cache/<name>), so we need to create
     # the parent directory if it doesn't exist to avoid errors during writing.
     pathlib.Path(filepath).parent.mkdir(parents=True, exist_ok=True)
@@ -55,11 +55,10 @@ def write_class_files_to_stage(
 ) -> None:
     if os.name != "nt":
         filepath = f"/tmp/sas-{session.session_id}"
+        jar_name = f'{filepath}/{hashlib.sha256(str(files).encode("utf-8")).hexdigest()[:10]}.jar'
     else:
-        filepath = f"{tempfile.gettempdir()}/sas-{session.session_id}"
-    jar_name = (
-        f'{filepath}/{hashlib.sha256(str(files).encode("utf-8")).hexdigest()[:10]}.jar'
-    )
+        filepath = f"{tempfile.gettempdir()}\\sas-{session.session_id}"
+        jar_name = f'{filepath}\\{hashlib.sha256(str(files).encode("utf-8")).hexdigest()[:10]}.jar'
     with zipfile.ZipFile(jar_name, "w", zipfile.ZIP_DEFLATED) as jar:
         for name, path in files.items():
             jar.write(path, name)

snowflake/snowpark_connect/utils/context.py

@@ -30,6 +30,9 @@ _sql_aggregate_function_count = ContextVar[int](
     "_contains_aggregate_function", default=0
 )
 
+# Context for parsing map_partitions
+_map_partitions_stack = ContextVar[int]("_map_partitions_stack", default=0)
+
 # We have to generate our own plan IDs that are different from Spark's.
 # Spark plan IDs start at 0, so pick a "big enough" number to avoid overlaps.
 _STARTING_SQL_PLAN_ID = 0x80000000
@@ -49,6 +52,7 @@ _spark_client_type_regex = re.compile(r"spark/(?P<spark_version>\d+\.\d+\.\d+)")
 _current_operation = ContextVar[str]("_current_operation", default="default")
 _resolving_fun_args = ContextVar[bool]("_resolving_fun_args", default=False)
 _resolving_lambda_fun = ContextVar[bool]("_resolving_lambdas", default=False)
+_current_lambda_params = ContextVar[list[str]]("_current_lambda_params", default=[])
 
 _is_window_enabled = ContextVar[bool]("_is_window_enabled", default=False)
 _is_in_pivot = ContextVar[bool]("_is_in_pivot", default=False)
@@ -206,6 +210,16 @@ def push_evaluating_join_condition(join_type, left_keys, right_keys):
         _is_evaluating_join_condition.set(prev)
 
 
+@contextmanager
+def push_map_partitions():
+    _map_partitions_stack.set(_map_partitions_stack.get() + 1)
+    yield
+
+
+def map_partitions_depth() -> int:
+    return _map_partitions_stack.get()
+
+
 @contextmanager
 def push_sql_scope():
     """
@@ -238,16 +252,21 @@ def push_operation_scope(operation: str):
 
 
 @contextmanager
-def resolving_lambda_function():
+def resolving_lambda_function(param_names: list[str] = None):
     """
     Context manager that sets a flag indicating lambda function is being resolved.
+    Also tracks the lambda parameter names for validation.
     """
     prev = _resolving_lambda_fun.get()
+    prev_params = _current_lambda_params.get()
     try:
         _resolving_lambda_fun.set(True)
+        if param_names is not None:
+            _current_lambda_params.set(param_names)
         yield
     finally:
         _resolving_lambda_fun.set(prev)
+        _current_lambda_params.set(prev_params)
 
 
 def is_lambda_being_resolved() -> bool:
@@ -257,6 +276,13 @@ def is_lambda_being_resolved() -> bool:
     return _resolving_lambda_fun.get()
 
 
+def get_current_lambda_params() -> list[str]:
+    """
+    Returns the current lambda parameter names.
+    """
+    return _current_lambda_params.get()
+
+
 @contextmanager
 def resolving_fun_args():
     """
@@ -270,6 +296,19 @@ def resolving_fun_args():
         _resolving_fun_args.set(prev)
 
 
+@contextmanager
+def not_resolving_fun_args():
+    """
+    Context manager that sets a flag indicating function arguments are *not* being resolved.
+    """
+    prev = _resolving_fun_args.get()
+    try:
+        _resolving_fun_args.set(False)
+        yield
+    finally:
+        _resolving_fun_args.set(prev)
+
+
 def is_function_argument_being_resolved() -> bool:
     """
     Returns True if function arguments are being resolved.
@@ -350,6 +389,7 @@ def clear_context_data() -> None:
 
     _next_sql_plan_id.set(_STARTING_SQL_PLAN_ID)
     _sql_plan_name_map.set({})
+    _map_partitions_stack.set(0)
     _sql_aggregate_function_count.set(0)
     _sql_named_args.set({})
     _sql_pos_args.set({})

snowflake/snowpark_connect/utils/pandas_udtf_utils.py

@@ -87,9 +87,93 @@ def get_map_in_arrow_udtf(
 def create_pandas_udtf(
     udtf_proto: CommonInlineUserDefinedFunction,
     spark_column_names: list[str],
-    input_schema: StructType | None = None,
-    return_schema: StructType | None = None,
+    input_schema: StructType,
+    return_schema: StructType,
+):
+    user_function, _ = cloudpickle.loads(udtf_proto.python_udf.command)
+    output_column_names = [field.name for field in return_schema.fields]
+    output_column_original_names = [
+        field.original_column_identifier for field in return_schema.fields
+    ]
+
+    class MapPandasUDTF:
+        def __init__(self) -> None:
+            self.user_function = user_function
+            self.output_column_names = output_column_names
+            self.spark_column_names = spark_column_names
+            self.output_column_original_names = output_column_original_names
+
+        def end_partition(self, df: pd.DataFrame):
+            if df.empty:
+                empty_df = pd.DataFrame(columns=self.output_column_names)
+                yield empty_df
+                return
+
+            df_without_dummy = df.drop(
+                columns=["_DUMMY_PARTITION_KEY"], errors="ignore"
+            )
+            df_without_dummy.columns = self.spark_column_names
+            result_iterator = self.user_function(
+                [pd.DataFrame([row]) for _, row in df_without_dummy.iterrows()]
+            )
+
+            if not isinstance(result_iterator, Iterator) and not hasattr(
+                result_iterator, "__iter__"
+            ):
+                raise RuntimeError(
+                    f"snowpark_connect::UDF_RETURN_TYPE Return type of the user-defined function should be "
+                    f"iterator of pandas.DataFrame, but is {type(result_iterator).__name__}"
+                )
+
+            output_df = pd.concat(result_iterator)
+            generated_output_column_names = list(output_df.columns)
+
+            missing_columns = []
+            for original_column in self.output_column_original_names:
+                if original_column not in generated_output_column_names:
+                    missing_columns.append(original_column)
+
+            if missing_columns:
+                unexpected_columns = [
+                    column
+                    for column in generated_output_column_names
+                    if column not in self.output_column_original_names
+                ]
+                raise RuntimeError(
+                    f"[RESULT_COLUMNS_MISMATCH_FOR_PANDAS_UDF] Column names of the returned pandas.DataFrame do not match specified schema. Missing: {', '.join(sorted(missing_columns))}. Unexpected: {', '.join(sorted(unexpected_columns))}"
+                    "."
+                )
+            reordered_df = output_df[self.output_column_original_names]
+            reordered_df.columns = self.output_column_names
+            yield reordered_df
+
+    return snowpark_fn.pandas_udtf(
+        MapPandasUDTF,
+        output_schema=PandasDataFrameType(
+            [field.datatype for field in return_schema.fields],
+            [field.name for field in return_schema.fields],
+        ),
+        input_types=[
+            PandasDataFrameType(
+                [field.datatype for field in input_schema.fields] + [IntegerType()]
+            )
+        ],
+        input_names=[field.name for field in input_schema.fields]
+        + ["_DUMMY_PARTITION_KEY"],
+        name="map_pandas_udtf",
+        replace=True,
+        packages=["pandas"],
+        is_permanent=False,
+    )
+
+
+def create_pandas_udtf_with_arrow(
+    udtf_proto: CommonInlineUserDefinedFunction,
+    spark_column_names: list[str],
+    input_schema: StructType,
+    return_schema: StructType,
 ) -> str | snowpark.udtf.UserDefinedTableFunction:
+
     user_function, _ = cloudpickle.loads(udtf_proto.python_udf.command)
     output_column_names = [field.name for field in return_schema.fields]
 

snowflake/snowpark_connect/utils/udf_utils.py

@@ -6,7 +6,6 @@
 # So its dependencies are restricted to pandas, snowpark, and, pyspark
 import functools
 import inspect
-from typing import Iterator
 
 import pandas
 import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
@@ -198,111 +197,75 @@ class ProcessCommonInlineUserDefinedFunction:
 
         needs_struct_conversion = isinstance(self._original_return_type, StructType)
 
-        match self._called_from:
-            case "map_map_partitions":
-                column_names = self._input_column_names
-                eval_type = self._eval_type
+        if not needs_struct_conversion:
+            return snowpark_fn.udf(
+                create_null_safe_wrapper(callable_func),
+                return_type=self._return_type,
+                input_types=self._input_types,
+                name=self._udf_name,
+                replace=self._replace,
+                packages=packages,
+                imports=imports,
+                immutable=self._is_deterministic,
+            )
 
-                def wrapped_function(*args):
-                    result = callable_func(
-                        pandas.DataFrame(iter([list(args)]), columns=column_names)
-                    )
-                    if eval_type == MAP_IN_ARROW_EVAL_TYPE:
-                        if not isinstance(result, Iterator) and not hasattr(
-                            result, "__iter__"
-                        ):
-                            raise RuntimeError(
-                                f"snowpark_connect::UDF_RETURN_TYPE Return type of the user-defined function should be "
-                                f"iterator of pyarrow.RecordBatch, but is {type(result).__name__}"
-                            )
-                        import pyarrow as pa
-
-                        for elem in result:
-                            if not isinstance(elem, pa.RecordBatch):
-                                raise RuntimeError(
-                                    f"snowpark_connect::UDF_RETURN_TYPE Return type of the user-defined function should "
-                                    f"be iterator of pyarrow.RecordBatch, but is iterator of {type(elem).__name__}"
-                                )
-                    return result
-
-                udf_function = create_null_safe_wrapper(wrapped_function)
-                packages += ["pyarrow", "pandas"]
-            case _:
-                if not needs_struct_conversion:
-                    return snowpark_fn.udf(
-                        create_null_safe_wrapper(callable_func),
-                        return_type=self._return_type,
-                        input_types=self._input_types,
-                        name=self._udf_name,
-                        replace=self._replace,
-                        packages=packages,
-                        imports=imports,
-                        immutable=self._is_deterministic,
+        is_pandas_udf, _, return_types, _ = extract_return_input_types(
+            callable_func,
+            self._original_return_type,
+            self._input_types,
+            TempObjectType.FUNCTION,
+        )
+        if is_pandas_udf and isinstance(return_types, PandasDataFrameType):
+            # Snowpark Python UDFs only support returning a Pandas Series.
+            # We change the return type to make the input callable compatible with Snowpark Python UDFs,
+            # and then in the wrapper function we convert the pandas DataFrame of the
+            # original callable to a Pandas Series.
+            original_callable.__annotations__["return"] = pandas.Series
+
+        field_names = [field.name for field in self._original_return_type.fields]
+
+        def struct_wrapper(*args):
+            result = callable_func(*args)
+            if isinstance(result, (tuple, list)):
+                # Convert tuple/list to dict using struct field names
+                if len(result) == len(field_names):
+                    return dict(zip(field_names, result))
+            return result
+
+        def pandas_struct_wrapper(*args):
+            # inspired by the following snowpark modin code to handle Pandas int/bool/null data in Snowflake VariantType
+            # https://github.com/snowflakedb/snowpark-python/blob/e095d5a54f3a697416c3f1df87d239def47a5495/src/snowflake/snowpark/modin/plugin/_internal/apply_utils.py#L1309-L1366
+            def convert_to_snowflake_compatible_type(value):
+                import numpy as np
+                from pandas.api.types import is_scalar
+
+                if is_scalar(value) and pandas.isna(value):
+                    return None
+
+                return (
+                    int(value)
+                    if np.issubdtype(type(value), np.integer)
+                    else (
+                        bool(value) if np.issubdtype(type(value), np.bool_) else value
                     )
-
-                is_pandas_udf, _, return_types, _ = extract_return_input_types(
-                    callable_func,
-                    self._original_return_type,
-                    self._input_types,
-                    TempObjectType.FUNCTION,
                 )
-                if is_pandas_udf and isinstance(return_types, PandasDataFrameType):
-                    # Snowpark Python UDFs only support returning a Pandas Series.
-                    # We change the return type to make the input callable compatible with Snowpark Python UDFs,
-                    # and then in the wrapper function we convert the pandas DataFrame of the
-                    # original callable to a Pandas Series.
-                    original_callable.__annotations__["return"] = pandas.Series
-
-                field_names = [
-                    field.name for field in self._original_return_type.fields
-                ]
-
-                def struct_wrapper(*args):
-                    result = callable_func(*args)
-                    if isinstance(result, (tuple, list)):
-                        # Convert tuple/list to dict using struct field names
-                        if len(result) == len(field_names):
-                            return dict(zip(field_names, result))
-                    return result
-
-                def pandas_struct_wrapper(*args):
-                    # inspired by the following snowpark modin code to handle Pandas int/bool/null data in Snowflake VariantType
-                    # https://github.com/snowflakedb/snowpark-python/blob/e095d5a54f3a697416c3f1df87d239def47a5495/src/snowflake/snowpark/modin/plugin/_internal/apply_utils.py#L1309-L1366
-                    def convert_to_snowflake_compatible_type(value):
-                        import numpy as np
-                        from pandas.api.types import is_scalar
-
-                        if is_scalar(value) and pandas.isna(value):
-                            return None
-
-                        return (
-                            int(value)
-                            if np.issubdtype(type(value), np.integer)
-                            else (
-                                bool(value)
-                                if np.issubdtype(type(value), np.bool_)
-                                else value
-                            )
-                        )
-
-                    result = callable_func(*args)
-                    assert (
-                        len(result) == 1
-                    ), "Expected result to be a single row DataFrame"
-                    # df.applymap doesn't help here, the original type was preserved, hence we convert each value
-                    row_data = [
-                        convert_to_snowflake_compatible_type(value)
-                        for value in result.iloc[0].tolist()
-                    ]
-                    result = pandas.Series([dict(zip(field_names, row_data))])
-                    return result
-
-                if is_pandas_udf:
-                    udf_function = pandas_struct_wrapper
-                    if isinstance(return_types, PandasDataFrameType):
-                        udf_function.__annotations__ = original_callable.__annotations__
-                else:
-                    udf_function = create_null_safe_wrapper(struct_wrapper)
+
+            result = callable_func(*args)
+            assert len(result) == 1, "Expected result to be a single row DataFrame"
+            # df.applymap doesn't help here, the original type was preserved, hence we convert each value
+            row_data = [
+                convert_to_snowflake_compatible_type(value)
+                for value in result.iloc[0].tolist()
+            ]
+            result = pandas.Series([dict(zip(field_names, row_data))])
+            return result
+
+        if is_pandas_udf:
+            udf_function = pandas_struct_wrapper
+            if isinstance(return_types, PandasDataFrameType):
+                udf_function.__annotations__ = original_callable.__annotations__
+        else:
+            udf_function = create_null_safe_wrapper(struct_wrapper)
 
         return snowpark_fn.udf(
             udf_function,

snowflake/snowpark_connect/utils/udtf_helper.py

@@ -261,15 +261,25 @@ def create(session, b64_str, spark_column_names_json_str, input_schema_json_str,
     udf_proto = CommonInlineUserDefinedFunction()
     udf_proto.ParseFromString(restored_bytes)
 
+    if not input_schema_json_str:
+        raise ValueError("Input schema is required for pandas UDTF.")
+    if not return_schema_json_str:
+        raise ValueError("Return schema is required for pandas UDTF.")
+
     spark_column_names = json.loads(spark_column_names_json_str)
-    input_schema = StructType.fromJson(json.loads(input_schema_json_str)) if input_schema_json_str else None
-    return_schema = StructType.fromJson(json.loads(return_schema_json_str)) if return_schema_json_str else None
+    input_schema = StructType.fromJson(json.loads(input_schema_json_str))
+    return_schema = StructType.fromJson(json.loads(return_schema_json_str))
 
-    map_in_arrow_udtf = create_pandas_udtf(
-        udf_proto, spark_column_names,
-        input_schema, return_schema
-    )
-    return map_in_arrow_udtf.name
+    map_in_arrow = udf_proto.WhichOneof("function") == "python_udf" and udf_proto.python_udf.eval_type == 207
+    if map_in_arrow:
+        map_udtf = create_pandas_udtf_with_arrow(
+            udf_proto, spark_column_names, input_schema, return_schema
+        )
+    else:
+        map_udtf = create_pandas_udtf(
+            udf_proto, spark_column_names, input_schema, return_schema
+        )
+    return map_udtf.name
 $$;
 """
     session.sql(create_udtf_sproc_sql).collect()

snowflake/snowpark_connect/version.py

@@ -1,6 +1,5 @@
-#!/usr/bin/env python3
+# !/usr/bin/env python3
 #
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
-
-VERSION = (0, 26, 0)
+VERSION = (0,27,0)

{snowpark_connect-0.26.0.dist-info → snowpark_connect-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.26.0
+Version: 0.27.0
 Summary: Snowpark Connect for Spark
 Author: Snowflake, Inc
 License: Apache License, Version 2.0
@@ -16,7 +16,7 @@ Requires-Dist: jpype1
 Requires-Dist: protobuf<5.0,>=4.25.3
 Requires-Dist: s3fs>=2025.3.0
 Requires-Dist: snowflake.core<2,>=1.0.5
-Requires-Dist: snowflake-snowpark-python[pandas]<1.38.0,>=1.37.0
+Requires-Dist: snowflake-snowpark-python[pandas]<1.39.0,==1.38.0
 Requires-Dist: sqlglot>=26.3.8
 Requires-Dist: jaydebeapi
 Requires-Dist: aiobotocore~=2.23.0

{snowpark_connect-0.26.0.dist-info → snowpark_connect-0.27.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 snowflake/snowpark_connect/__init__.py,sha256=Sml4x1LTNnxZyw6nnDeJrZWUi3eUAR46Rsw6N-wHUSA,605
 snowflake/snowpark_connect/column_name_handler.py,sha256=_bTrguwdiF_cqFvoihFU7f42lNqtJ3Af-9fPvSLbf_A,31919
-snowflake/snowpark_connect/config.py,sha256=KQlRIZsclZfzWe3Co4XBvT_WBeuC6xb9GNAnGEeOWPY,25094
+snowflake/snowpark_connect/config.py,sha256=3rdbc05u0IcivwsdUwV4Wg9u6Tf-AhPT2INIinhv1PY,24948
 snowflake/snowpark_connect/constants.py,sha256=FBDxNUxdqWxnf6d5-eanHlYdFFyQqCqvNyZG-uOiO6Q,598
 snowflake/snowpark_connect/control_server.py,sha256=mz3huYo84hgqUB6maZxu3LYyGq7vVL1nv7-7-MjuSYY,1956
 snowflake/snowpark_connect/dataframe_container.py,sha256=sCzMxzb6UIJz1mVpwzSYeVBiqtSzZv5n_pn7FVhbRv0,9114
@@ -9,12 +9,12 @@ snowflake/snowpark_connect/date_time_format_mapping.py,sha256=qtQ-JTGR1VRWM2oxM1
 snowflake/snowpark_connect/empty_dataframe.py,sha256=aKO6JkYnArWCpLGcn9BzvTspw2k_c6eAM0mQImAY0J0,428
 snowflake/snowpark_connect/hidden_column.py,sha256=k56-e97vqQmoOFtOtIPy6rSu8mZAz-toKHoIBXYW3CU,1322
 snowflake/snowpark_connect/resources_initializer.py,sha256=njE4_L82evaCwFYPGBUX6OEVaHqww42oGXXmzUylt0I,4424
-snowflake/snowpark_connect/server.py,sha256=JRgj7PXJAPZ1LyoRs6heMh2ISXjhOMIxw3sipXlhQd8,50978
+snowflake/snowpark_connect/server.py,sha256=uYw0pbpWmgfRkrgI5Q5vFsu3Ng-5_H3SR86KkC13S8M,51108
 snowflake/snowpark_connect/start_server.py,sha256=udegO0rk2FeSnXsIcCIYQW3VRlGDjB_cU8lJ8xSzuM8,942
 snowflake/snowpark_connect/tcm.py,sha256=ftncZFbVO-uyWMhF1_HYKQykB7KobHEYoyQsYbQj1EM,203
 snowflake/snowpark_connect/type_mapping.py,sha256=6Hg-h1iVzVB_FnwG3Sjl-UGr2Itrs4LxVb2Pz5Ue-YA,41566
 snowflake/snowpark_connect/typed_column.py,sha256=Tavii8b4zMj5IWOvN6tlOVmC80W6eQct0pC_tF2nlhU,3867
-snowflake/snowpark_connect/version.py,sha256=n9kt8bTa93V973HaRfyqLqeVkvUhOJqglXJqOAdmsWw,121
+snowflake/snowpark_connect/version.py,sha256=7e7JVBr1dPQ6_J46i0ARFv1O8q5XD9BxRNnNSMkrI0M,118
 snowflake/snowpark_connect/analyze_plan/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
 snowflake/snowpark_connect/analyze_plan/map_tree_string.py,sha256=Q3ZD-Z7uForrF7W3mSAjwaiEcIv2KDXr5jPfVbromVg,1470
 snowflake/snowpark_connect/error/__init__.py,sha256=oQo6k4zztLmNF1c5IvJLcS99J6RWY9KBTN3RJ2pKimg,249
@@ -30,13 +30,13 @@ snowflake/snowpark_connect/expression/function_defaults.py,sha256=WEnzc_uzZZltcf
 snowflake/snowpark_connect/expression/hybrid_column_map.py,sha256=2jItaXnFnqcaOIiHKxscFLj7hi2zQE7F3xcher8Zo2U,7614
 snowflake/snowpark_connect/expression/literal.py,sha256=wk5NnLR85SLHe7GoAvSzMTW0B-3yhAiRz4F5SfU2REs,4459
 snowflake/snowpark_connect/expression/map_cast.py,sha256=uxNukg9op0i_sKLhY43fJJJ2-SKZ-8wkRMRBiPikJ0c,14799
-snowflake/snowpark_connect/expression/map_expression.py,sha256=cotjHDdKiHWbQZx3buBcISCnty8TYyUbbUat4W9qhIk,14119
+snowflake/snowpark_connect/expression/map_expression.py,sha256=Jj8boZ3rSypGM26_g5yL4DJ1z5L_p70_-E5XNriLZN0,14949
 snowflake/snowpark_connect/expression/map_extension.py,sha256=Qm1Jn3JunswD_hO7ornvKpR6WcM3UKO_JpZE6ovH3VM,4939
 snowflake/snowpark_connect/expression/map_sql_expression.py,sha256=bHl7_YrKnWy0k1gMz02HYF8lTZKoamQdv5nFCHEfbzI,25824
 snowflake/snowpark_connect/expression/map_udf.py,sha256=_om_Kqxm_sm3RhwP4DZbGPUpArX90MoJQm-KwEWrTiQ,8034
-snowflake/snowpark_connect/expression/map_unresolved_attribute.py,sha256=xIJYxs1EJZNs1skX_xgshvcddsqO8jHgR9QUEvwXm9E,18520
+snowflake/snowpark_connect/expression/map_unresolved_attribute.py,sha256=fnkCQF-Ts-Dw93AlwjzQdd9BAR5J4uldML8dZ3J_RMI,19576
 snowflake/snowpark_connect/expression/map_unresolved_extract_value.py,sha256=A-m-RczZW6xHMjgYR5RV_vzMTpNBRoH3Tk_A1V8z_pk,5382
-snowflake/snowpark_connect/expression/map_unresolved_function.py,sha256=x8LRI_BXgnclTEfCkJp6O8CPkxsYTc4fYGK_zPGpGdM,477028
+snowflake/snowpark_connect/expression/map_unresolved_function.py,sha256=ZnltrpyzLNn4eu0Eg7axYZVsixt9wTtA0JrAVSh9Ojw,477459
 snowflake/snowpark_connect/expression/map_unresolved_star.py,sha256=XNJurGS5RLAaIAcalGGBbPJujqg8YZru_RsoB61m0WQ,8865
 snowflake/snowpark_connect/expression/map_update_fields.py,sha256=bMuZjCOE5wgrZv3ApsoiwEUv-lPgnMWUk-DFX11QuX0,6710
 snowflake/snowpark_connect/expression/map_window_function.py,sha256=apJxtWSnLogMG0F_En67JoGrGRGYQ0I8O0xPRk4TR_o,12152
@@ -401,15 +401,15 @@ snowflake/snowpark_connect/relation/map_aggregate.py,sha256=KElVYO62V3jkU8ldTCfT
 snowflake/snowpark_connect/relation/map_catalog.py,sha256=mcx6An4fqHAxy2OhOC66Xe_0aRtYPDGkBEgMK5CfaXU,5822
 snowflake/snowpark_connect/relation/map_column_ops.py,sha256=grleA0S6jyia6T5IGbPOEdz0zI0TkkV7jENzlfzoQlQ,49017
 snowflake/snowpark_connect/relation/map_crosstab.py,sha256=H_J8-IARK6zMEUFrOjKif1St6M20gvBAnP0EuArFHGg,2422
-snowflake/snowpark_connect/relation/map_extension.py,sha256=OeaCtrmvRJBfn6TKJ-tb9ynoBs6QybGOsDJqaJMSkjw,22172
+snowflake/snowpark_connect/relation/map_extension.py,sha256=aZUKnOhpVUrgt8-hRbP7JdVfA453vg9YaWaVKQVEsC4,22271
 snowflake/snowpark_connect/relation/map_join.py,sha256=oINd7AMa_O0bLPqsFFeKnZfE0anKa2RAR9QYh3qdbbY,25042
 snowflake/snowpark_connect/relation/map_local_relation.py,sha256=VBfwBT75GQUe01UOZptwcYsI7zZxaIMQyTOG6kmVuJ0,15219
-snowflake/snowpark_connect/relation/map_map_partitions.py,sha256=2vN7wfe0mR0qzMYeHOmWrgsdCq573j2qQSLnzp7pSFg,5881
-snowflake/snowpark_connect/relation/map_relation.py,sha256=gCko2zjUEBYkiw2GmJerGl-YcRAeONGTIF1GhoGhQl0,12468
+snowflake/snowpark_connect/relation/map_map_partitions.py,sha256=JGiPnqmFFNdHAx54dHyOUwo9JZzyggDd1yLBmu-hasQ,4307
+snowflake/snowpark_connect/relation/map_relation.py,sha256=LaISHm5KrLFb4VSgTT2n-9VL4LB21gaN9xl38qzZmT0,12541
 snowflake/snowpark_connect/relation/map_row_ops.py,sha256=x1Jqircy4I0iiSljx3zbq0YxwGvGzPcXIY8_nhtl2PM,30528
 snowflake/snowpark_connect/relation/map_sample_by.py,sha256=8ALQbeUsB89sI3uiUFqG3w1A4TtOzOAL4umdKp6-c38,1530
-snowflake/snowpark_connect/relation/map_show_string.py,sha256=fuYCuThp7V3VPb5NETJvW0JDf9Xv2qCxdvBmlbHgF7c,3254
-snowflake/snowpark_connect/relation/map_sql.py,sha256=UphF9mWLV8csDLNlFTTC0Xq2-OfoHI1ztcyAE5X6d-M,83484
+snowflake/snowpark_connect/relation/map_show_string.py,sha256=GgKg0qp1pGqSC7TuFedTU4IYaIm-Fx23OJ1LfkcGOHw,3382
+snowflake/snowpark_connect/relation/map_sql.py,sha256=BcgZMiyxDzy5cH8in_-O7819b3qGGaDxYNl0C_6Eqec,86496
 snowflake/snowpark_connect/relation/map_stats.py,sha256=kqRYvix8RfluTKx1cAy9JhBUv6arYQHgfxpP1R4QwBM,13985
 snowflake/snowpark_connect/relation/map_subquery_alias.py,sha256=rHgE9XUzuWWkjNPtJz3Sxzz2aFo690paHKZh9frqPXk,1456
 snowflake/snowpark_connect/relation/map_udtf.py,sha256=cfDnbZ3TRJ6eb0EVResu6GL-OwQpaEabWLbrhgWnkRw,13316
@@ -433,21 +433,21 @@ snowflake/snowpark_connect/relation/read/reader_config.py,sha256=PMh1R5IjqqTwiAA
 snowflake/snowpark_connect/relation/read/utils.py,sha256=rIIM6d2WXHh7MLGyHNiRc9tS8b0dmyFQr7rHepIYJOU,4111
 snowflake/snowpark_connect/relation/write/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
 snowflake/snowpark_connect/relation/write/jdbc_write_dbapi.py,sha256=GI9FyGZuQQNV-6Q8Ob-Xr0im3iAPdH-Jkyx8bjwbOuE,11931
-snowflake/snowpark_connect/relation/write/map_write.py,sha256=UE5A-m1NWgbziGbUiZh48YCZHwogwTegAXEPEcFuepg,39361
+snowflake/snowpark_connect/relation/write/map_write.py,sha256=02e5JkrS6yr8KYGyGehsSfLZLCNDJHUg8tAVkCUAEgk,40376
 snowflake/snowpark_connect/relation/write/map_write_jdbc.py,sha256=1nOWRgjtZzfRwnSRGFP9V6mqBVlGhSBr2KHGHbe4JMU,1404
 snowflake/snowpark_connect/resources/java_udfs-1.0-SNAPSHOT.jar,sha256=tVyOp6tXxu9nm6SDufwQiGzfH3pnuh_7PowsMZxOolY,9773
 snowflake/snowpark_connect/utils/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
-snowflake/snowpark_connect/utils/artifacts.py,sha256=CDSO9ve_yHvT1CKjoLnwiQNarsM5cMUdypGgpRELtK0,2407
+snowflake/snowpark_connect/utils/artifacts.py,sha256=TkHZ2uNfZiphgtG91V1_c_h9yP9dP677BXUMymboCss,2498
 snowflake/snowpark_connect/utils/cache.py,sha256=bAyoNBW6Z1ui9BuppDywbQeG6fdju4L-owFHzySOTnk,3382
 snowflake/snowpark_connect/utils/concurrent.py,sha256=2UrQfJPWFrtpx131514t-9aXFDphbGI3N2pumLrltNk,3543
-snowflake/snowpark_connect/utils/context.py,sha256=nZVj1EMH-aP32cKFCcHqDut3lPtdt0A8DniBzMxCS4k,12132
+snowflake/snowpark_connect/utils/context.py,sha256=W9j9eC-lbGp7tfXWhnvI88CVOcLGspYEhEgxGPYVbYE,13288
 snowflake/snowpark_connect/utils/describe_query_cache.py,sha256=2VcPgGP9bUpdIhnN2s_MOG8oGHKX0hS0rT7Y26MJb3A,9001
 snowflake/snowpark_connect/utils/env_utils.py,sha256=g__Uio5ae20Tm1evahIHdJUXQYPmjNUT_kYPSIy5JDU,1488
 snowflake/snowpark_connect/utils/external_udxf_cache.py,sha256=eSZHMbjTxnkg78IlbG5P1Vno6j5ag_FSI0c4Xi2UyPs,1044
 snowflake/snowpark_connect/utils/identifiers.py,sha256=YgtVIQGuUnnTiNdtRficdBwUICWaWkJltjOPnTnfrak,3881
 snowflake/snowpark_connect/utils/interrupt.py,sha256=_awhdrzF1KQO-EQThneEcfMg3Zxed4p3HtMpkcAb6ek,2790
 snowflake/snowpark_connect/utils/io_utils.py,sha256=noBlKpJvzEA6iwLjFgBVGlCLlzjZ16-w0fsGimTyBAQ,1039
-snowflake/snowpark_connect/utils/pandas_udtf_utils.py,sha256=QwdLGLg5bX0JJTrWKfL4Ou4MIp443cryEbrZNBrulNE,4207
+snowflake/snowpark_connect/utils/pandas_udtf_utils.py,sha256=3WA_9IVRZL8fnwIHo048LTg62-bPGfCDUZzYd-zjzQQ,7564
 snowflake/snowpark_connect/utils/profiling.py,sha256=ttdHzQUYarvTqJASLNuKFIax7ejO39Tv1mHKl0QjRkg,1519
 snowflake/snowpark_connect/utils/scala_udf_utils.py,sha256=YDHmhqsjgBeuKdv1TaInEUUOvrnbrU3_toQY_MfEygk,22895
 snowflake/snowpark_connect/utils/session.py,sha256=dxt5VoqsQqBZd3OaEpoPfA0U-uNFWDP-HWtrcoey7_w,7770
@@ -455,8 +455,8 @@ snowflake/snowpark_connect/utils/snowpark_connect_logging.py,sha256=23bvbALGqixJ
 snowflake/snowpark_connect/utils/telemetry.py,sha256=BRDX1eRXcww2SAiBlVr2fQVR2I6gH50qSCFkOop_x4M,20736
 snowflake/snowpark_connect/utils/udf_cache.py,sha256=8K7kASEhvpnp-l1hjzovjyboUzKctDq7PiGXRcNv6Lg,12125
 snowflake/snowpark_connect/utils/udf_helper.py,sha256=g-TxTs4ARyJWYgADrosfQQG-ykBBQdm1g5opslxJq_E,12563
-snowflake/snowpark_connect/utils/udf_utils.py,sha256=Ey_clI2d-1m4zc51JWNsl8m0i93cS2L9NboLGGVwII8,14213
-snowflake/snowpark_connect/utils/udtf_helper.py,sha256=nTWbrFMc4hHLkalT4nJIsC_c00T6GFkB55JHOw1D-wg,14571
+snowflake/snowpark_connect/utils/udf_utils.py,sha256=pxERcJKum2M5jHxPqsl1NgHFAqZV4RxoEnSLxJV5ups,12009
+snowflake/snowpark_connect/utils/udtf_helper.py,sha256=9B_1iOckfFXQfVv-UHerIJ32fDd4qucKaHGqxtBEi4w,14969
 snowflake/snowpark_connect/utils/udtf_utils.py,sha256=wHO5V0BXRQOLqAYos1vGt8bbdH7jBvD2gwspWywjTtY,33110
 snowflake/snowpark_connect/utils/udxf_import_utils.py,sha256=pPtcaGsyh0tUdy0aAvNqTj04jqPKlEcGmvaZDP9O8Gc,536
 snowflake/snowpark_connect/utils/xxhash64.py,sha256=ysJRxhBPf25LeNhM1RK_H36MWl6q6C6vBRHa-jIna_A,7477
@@ -465,17 +465,17 @@ snowflake/snowpark_decoder/dp_session.py,sha256=HIr3TfKgYl5zqaGR5xpFU9ZVkcaTB9I8
 snowflake/snowpark_decoder/spark_decoder.py,sha256=EQiCvBiqB736Bc17o3gnYGtcYVcyfGxroO5e1kbe1Co,2885
 snowflake/snowpark_decoder/_internal/proto/generated/DataframeProcessorMsg_pb2.py,sha256=2eSDqeyfMvmIJ6_rF663DrEe1dg_anrP4OpVJNTJHaQ,2598
 snowflake/snowpark_decoder/_internal/proto/generated/DataframeProcessorMsg_pb2.pyi,sha256=aIH23k52bXdw5vO3RtM5UcOjDPaWsJFx1SRUSk3qOK8,6142
-snowpark_connect-0.26.0.data/scripts/snowpark-connect,sha256=yZ94KqbWACxnwV8mpg8NjILvvRNjnF8B3cs3ZFNuIM4,1546
-snowpark_connect-0.26.0.data/scripts/snowpark-session,sha256=NMAHSonTo-nmOZSkQNlszUC0jLJ8QWEDUsUmMe2UAOw,190
-snowpark_connect-0.26.0.data/scripts/snowpark-submit,sha256=Zd98H9W_d0dIqMSkQLdHyW5G3myxF0t4c3vNBt2nD6A,12056
-snowpark_connect-0.26.0.dist-info/licenses/LICENSE-binary,sha256=fmBlX39HwTlBUyiKEznaLZGuxQy-7ndLLG_rTXjF02Y,22916
-snowpark_connect-0.26.0.dist-info/licenses/LICENSE.txt,sha256=Ff9cPv4xu0z7bnMTHzo4vDncOShsy33w4oJMA2xjn6c,11365
-snowpark_connect-0.26.0.dist-info/licenses/NOTICE-binary,sha256=elMF8brgGNJwOz8YdorzBF6-U8ZhR8F-77FfGkZng7U,57843
+snowpark_connect-0.27.0.data/scripts/snowpark-connect,sha256=yZ94KqbWACxnwV8mpg8NjILvvRNjnF8B3cs3ZFNuIM4,1546
+snowpark_connect-0.27.0.data/scripts/snowpark-session,sha256=NMAHSonTo-nmOZSkQNlszUC0jLJ8QWEDUsUmMe2UAOw,190
+snowpark_connect-0.27.0.data/scripts/snowpark-submit,sha256=Zd98H9W_d0dIqMSkQLdHyW5G3myxF0t4c3vNBt2nD6A,12056
+snowpark_connect-0.27.0.dist-info/licenses/LICENSE-binary,sha256=fmBlX39HwTlBUyiKEznaLZGuxQy-7ndLLG_rTXjF02Y,22916
+snowpark_connect-0.27.0.dist-info/licenses/LICENSE.txt,sha256=Ff9cPv4xu0z7bnMTHzo4vDncOShsy33w4oJMA2xjn6c,11365
+snowpark_connect-0.27.0.dist-info/licenses/NOTICE-binary,sha256=elMF8brgGNJwOz8YdorzBF6-U8ZhR8F-77FfGkZng7U,57843
 spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spark/connect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spark/connect/envelope_pb2.py,sha256=7Gc6OUA3vaCuTCIKamb_Iiw7W9jPTcWNEv1im20eWHM,2726
 spark/connect/envelope_pb2.pyi,sha256=VXTJSPpcxzB_dWqVdvPY4KkPhJfh0WmkX7SNHWoLhx0,3358
-snowpark_connect-0.26.0.dist-info/METADATA,sha256=IQ7OoHx9dFxYtBVJaEW2lsjfTj8-K-uyLr3Po1q2SBM,1594
-snowpark_connect-0.26.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-snowpark_connect-0.26.0.dist-info/top_level.txt,sha256=ExnWqVpoTHRG99fu_AxXZVOz8c-De7nNu0yFCGylM8I,16
-snowpark_connect-0.26.0.dist-info/RECORD,,
+snowpark_connect-0.27.0.dist-info/METADATA,sha256=w6hmGXXIiI6a74FuRcX7WiRBQP2ZlTVA_oqU1Lp8P0k,1594
+snowpark_connect-0.27.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+snowpark_connect-0.27.0.dist-info/top_level.txt,sha256=ExnWqVpoTHRG99fu_AxXZVOz8c-De7nNu0yFCGylM8I,16
+snowpark_connect-0.27.0.dist-info/RECORD,,