snowpark-connect 0.31.0__py3-none-any.whl → 0.32.0__py3-none-any.whl

snowflake/snowpark_connect/expression/map_unresolved_star.py

@@ -11,6 +11,7 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
 )
 from snowflake.snowpark.types import StructType
 from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.error.error_codes import ErrorCodes
 from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
 from snowflake.snowpark_connect.expression.typer import ExpressionTyper
@@ -28,7 +29,7 @@ def check_struct_and_get_field_datatype(field_name, schema):
         else:
             return None
     else:
-        None
+        return None
 
 
 def map_unresolved_star(
@@ -55,16 +56,17 @@ def map_unresolved_star(
             return spark_names, typed_column
 
         # scenario where it is expanding * to mulitple columns
-        spark_names = []
-        snowpark_names = []
-        qualifiers = []
+        spark_names: list[str] = []
+        snowpark_names: list[str] = []
+        qualifiers: list[set[ColumnQualifier]] = []
 
+        target_qualifier = ColumnQualifier(tuple(name_parts[:-1]))
         (
             spark_names,
             snowpark_names,
             qualifiers,
         ) = column_mapping.get_spark_and_snowpark_columns_with_qualifier_for_qualifier(
-            name_parts[:-1]
+            target_qualifier
         )
 
         if len(spark_names) == 0:
@@ -75,7 +77,7 @@ def map_unresolved_star(
                     snowpark_names,
                     qualifiers,
                 ) = column_mapping_for_outer_df.get_spark_and_snowpark_columns_with_qualifier_for_qualifier(
-                    name_parts[:-1]
+                    target_qualifier
                 )
                 if len(spark_names) > 0:
                     break
@@ -141,7 +143,7 @@ def map_unresolved_star(
                     final_sql_expr,
                     lambda final_sql_expr=final_sql_expr: typer.type(final_sql_expr),
                 )
-                typed_column.set_multi_col_qualifiers([[] for _ in spark_names])
+                typed_column.set_multi_col_qualifiers([set() for _ in spark_names])
                 return spark_names, typed_column
     else:
         result_exp = snowpark_fn.sql_expr(

snowflake/snowpark_connect/relation/catalogs/snowflake_catalog.py

@@ -19,6 +19,7 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
 )
 from snowflake.snowpark.functions import lit
 from snowflake.snowpark.types import BooleanType, StringType
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import (
     auto_uppercase_non_column_identifiers,
     global_config,
@@ -743,7 +744,9 @@ class SnowflakeCatalog(AbstractSparkCatalog):
         sp_schema = proto_to_snowpark_type(schema)
         columns = [c.name for c in schema.struct.fields]
         table_name_parts = split_fully_qualified_spark_name(tableName)
-        qualifiers = [table_name_parts for _ in columns]
+        qualifiers: list[set[ColumnQualifier]] = [
+            {ColumnQualifier(tuple(table_name_parts))} for _ in columns
+        ]
         column_types = [f.datatype for f in sp_schema.fields]
         return DataFrameContainer.create_with_column_mapping(
             dataframe=session.createDataFrame([], sp_schema),

snowflake/snowpark_connect/relation/map_aggregate.py

@@ -16,6 +16,7 @@ from snowflake.snowpark.types import DataType
 from snowflake.snowpark_connect.column_name_handler import (
     make_column_names_snowpark_compatible,
 )
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.expression.literal import get_literal_field_and_name
 from snowflake.snowpark_connect.expression.map_expression import (
@@ -200,7 +201,9 @@ def map_pivot_aggregate(
                 dataframe=result.select(*column_selectors),
                 spark_column_names=reordered_spark_names,
                 snowpark_column_names=reordered_snowpark_names,
-                column_qualifiers=[[]] * len(reordered_spark_names),
+                column_qualifiers=[
+                    {ColumnQualifier.no_qualifier()} for _ in reordered_spark_names
+                ],
                 parent_column_name_map=input_container.column_map,
                 snowpark_column_types=reordered_types,
             )
@@ -349,7 +352,7 @@ class _ColumnMetadata:
     spark_name: str
     snowpark_name: str
     data_type: DataType
-    qualifiers: list[str]
+    qualifiers: set[ColumnQualifier]
 
 
 @dataclass(frozen=True)
@@ -385,7 +388,7 @@ class _Columns:
             col.spark_name for col in self.grouping_columns + self.aggregation_columns
         ]
 
-    def get_qualifiers(self) -> list[list[str]]:
+    def get_qualifiers(self) -> list[set[ColumnQualifier]]:
         return [
             col.qualifiers for col in self.grouping_columns + self.aggregation_columns
         ]
@@ -429,7 +432,7 @@ def map_aggregate_helper(
                     new_name,
                     None if skip_alias else alias,
                     None if pivot else snowpark_column.typ,
-                    snowpark_column.get_qualifiers(),
+                    qualifiers=snowpark_column.get_qualifiers(),
                 )
             )
 
@@ -469,7 +472,7 @@ def map_aggregate_helper(
                     new_name,
                     None if skip_alias else alias,
                     agg_col_typ,
-                    [],
+                    qualifiers={ColumnQualifier.no_qualifier()},
                 )
             )
 

snowflake/snowpark_connect/relation/map_column_ops.py

@@ -29,6 +29,7 @@ from snowflake.snowpark.column import Column
 from snowflake.snowpark.table_function import _ExplodeFunctionCall
 from snowflake.snowpark.types import DataType, StructField, StructType, _NumericType
 from snowflake.snowpark_connect.column_name_handler import (
+    ColumnQualifier,
     make_column_names_snowpark_compatible,
 )
 from snowflake.snowpark_connect.config import global_config
@@ -1014,7 +1015,7 @@ def map_unpivot(
     column_project = []
     column_reverse_project = []
     snowpark_columns = []
-    qualifiers = []
+    qualifiers: list[set[ColumnQualifier]] = []
     for c in input_container.column_map.get_snowpark_columns():
         c_name = snowpark_functions_col(c, input_container.column_map).get_name()
         if c_name in unpivot_col_names:
@@ -1042,7 +1043,7 @@ def map_unpivot(
             )
             snowpark_columns.append(c)
             qualifiers.append(
-                input_container.column_map.get_qualifier_for_spark_column(c)
+                input_container.column_map.get_qualifiers_for_spark_column(c)
             )
 
     # Without the case when postprocessing, the result Spark dataframe is:
@@ -1087,7 +1088,7 @@ def map_unpivot(
         snowpark_functions_col(snowpark_value_column_name, input_container.column_map)
     )
     snowpark_columns.append(snowpark_value_column_name)
-    qualifiers.extend([[]] * 2)
+    qualifiers.extend([set() for _ in range(2)])
 
     result = (
         input_df.select(*column_project)

snowflake/snowpark_connect/relation/map_extension.py

@@ -15,6 +15,7 @@ from snowflake.snowpark_connect.column_name_handler import (
     ColumnNameMap,
     make_column_names_snowpark_compatible,
 )
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import get_boolean_session_config_param
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.error.error_codes import ErrorCodes
@@ -178,7 +179,7 @@ def get_udtf_project(relation: relation_proto.Relation) -> bool:
 
 def handle_udtf_with_table_arguments(
     udtf_info: snowflake_proto.UDTFWithTableArguments,
-) -> snowpark.DataFrame:
+) -> DataFrameContainer:
     """
     Handle UDTF with one or more table arguments using Snowpark's join_table_function.
     For multiple table arguments, this creates a Cartesian product of all input tables.
@@ -286,7 +287,7 @@ def handle_lateral_join_with_udtf(
     left_result: DataFrameContainer,
     udtf_relation: relation_proto.Relation,
     udtf_info: tuple[snowpark.udtf.UserDefinedTableFunction, list],
-) -> snowpark.DataFrame:
+) -> DataFrameContainer:
     """
     Handle lateral join with UDTF on the right side using join_table_function.
     """
@@ -319,7 +320,7 @@ def handle_lateral_join_with_udtf(
 
 def map_aggregate(
     aggregate: snowflake_proto.Aggregate, plan_id: int
-) -> snowpark.DataFrame:
+) -> DataFrameContainer:
     input_container = map_relation(aggregate.input)
     input_df: snowpark.DataFrame = input_container.dataframe
 
@@ -363,7 +364,7 @@ def map_aggregate(
         return new_names[0], snowpark_column
 
     raw_groupings: list[tuple[str, TypedColumn]] = []
-    raw_aggregations: list[tuple[str, TypedColumn, list[str]]] = []
+    raw_aggregations: list[tuple[str, TypedColumn, set[ColumnQualifier]]] = []
 
     if not is_group_by_all:
         raw_groupings = [_map_column(exp) for exp in aggregate.grouping_expressions]
@@ -401,11 +402,11 @@ def map_aggregate(
         col = _map_column(exp)
         if exp.WhichOneof("expr_type") == "unresolved_attribute":
             spark_name = col[0]
-            qualifiers = input_container.column_map.get_qualifier_for_spark_column(
-                spark_name
-            )
+            qualifiers: set[
+                ColumnQualifier
+            ] = input_container.column_map.get_qualifiers_for_spark_column(spark_name)
         else:
-            qualifiers = []
+            qualifiers = set()
 
         raw_aggregations.append((col[0], col[1], qualifiers))
 
@@ -438,7 +439,7 @@ def map_aggregate(
     spark_columns: list[str] = []
     snowpark_columns: list[str] = []
     snowpark_column_types: list[snowpark_types.DataType] = []
-    all_qualifiers: list[list[str]] = []
+    all_qualifiers: list[set[ColumnQualifier]] = []
 
     # Use grouping columns directly without aliases
     groupings = [col.col for _, col in raw_groupings]

snowflake/snowpark_connect/relation/map_join.py

@@ -10,6 +10,7 @@ from pyspark.errors import AnalysisException
 import snowflake.snowpark.functions as snowpark_fn
 from snowflake import snowpark
 from snowflake.snowpark_connect.column_name_handler import JoinColumnNameMap
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.constants import COLUMN_METADATA_COLLISION_KEY
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
@@ -267,8 +268,10 @@ def map_join(rel: relation_proto.Relation) -> DataFrameContainer:
             ]  # this is to make sure we only remove the column once
         ]
 
-        qualifiers = list(left_container.column_map.get_qualifiers()) + [
-            right_container.column_map.get_qualifier_for_spark_column(spark_col)
+        qualifiers: list[set[ColumnQualifier]] = list(
+            left_container.column_map.get_qualifiers()
+        ) + [
+            {right_container.column_map.get_qualifier_for_spark_column(spark_col)}
             for i, spark_col in enumerate(
                 right_container.column_map.get_spark_columns()
             )

snowflake/snowpark_connect/relation/map_sql.py

@@ -1343,6 +1343,33 @@ def map_sql_to_pandas_df(
                 )
                 SNOWFLAKE_CATALOG.refreshTable(table_name_unquoted)
 
+                return pandas.DataFrame({"": [""]}), ""
+            case "RepairTable":
+                # No-Op. Snowflake doesn't have explicit partitions to repair.
+                table_relation = logical_plan.child()
+                db_and_table_name = as_java_list(table_relation.multipartIdentifier())
+                multi_part_len = len(db_and_table_name)
+
+                if multi_part_len == 1:
+                    table_name = db_and_table_name[0]
+                    db_name = None
+                    full_table_name = table_name
+                else:
+                    db_name = db_and_table_name[0]
+                    table_name = db_and_table_name[1]
+                    full_table_name = db_name + "." + table_name
+
+                df = SNOWFLAKE_CATALOG.tableExists(table_name, db_name)
+
+                table_exist = df.iloc[0, 0]
+
+                if not table_exist:
+                    exception = AnalysisException(
+                        f"[TABLE_OR_VIEW_NOT_FOUND] Table not found `{full_table_name}`."
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+                    raise exception
+
                 return pandas.DataFrame({"": [""]}), ""
             case _:
                 execute_logical_plan(logical_plan)
@@ -1483,7 +1510,12 @@ def map_sql(
     snowpark_connect_sql_passthrough, sql_stmt = is_valid_passthrough_sql(rel.sql.query)
 
     if not snowpark_connect_sql_passthrough:
-        logical_plan = sql_parser().parseQuery(sql_stmt)
+        # Changed from parseQuery to parsePlan as Spark parseQuery() call generating wrong logical plan for
+        # query like this: SELECT cast('3.4' as decimal(38, 18)) UNION SELECT 'foo'
+        # As such other place in this file we use parsePlan.
+        # Main difference between parsePlan() and parseQuery() is, parsePlan() can be called for any SQL statement, while
+        # parseQuery() can only be called for query statements.
+        logical_plan = sql_parser().parsePlan(sql_stmt)
 
         parsed_pos_args = parse_pos_args(logical_plan, rel.sql.pos_args)
         set_sql_args(rel.sql.args, parsed_pos_args)

snowflake/snowpark_connect/relation/map_subquery_alias.py

@@ -4,6 +4,7 @@
 
 import pyspark.sql.connect.proto.relations_pb2 as relation_proto
 
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.map_relation import map_relation
 
@@ -18,7 +19,9 @@ def map_alias(
     # we set reuse_parsed_plan=False because we need new expr_id for the attributes (output columns) in aliased snowpark dataframe
     # reuse_parsed_plan will lead to ambiguous column name for operations like joining two dataframes that are aliased from the same dataframe
     input_container = map_relation(rel.subquery_alias.input, reuse_parsed_plan=False)
-    qualifiers = [[alias]] * len(input_container.column_map.columns)
+    qualifiers = [
+        {ColumnQualifier((alias,))} for _ in input_container.column_map.columns
+    ]
 
     return DataFrameContainer.create_with_column_mapping(
         dataframe=input_container.dataframe,

snowflake/snowpark_connect/relation/read/map_read_table.py

@@ -16,6 +16,7 @@ from snowflake.snowpark_connect.column_name_handler import (
     ColumnNameMap,
     make_column_names_snowpark_compatible,
 )
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import auto_uppercase_non_column_identifiers
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.error.error_codes import ErrorCodes
@@ -58,7 +59,7 @@ def post_process_df(
             spark_column_names=true_names,
             snowpark_column_names=snowpark_column_names,
             snowpark_column_types=[f.datatype for f in df.schema.fields],
-            column_qualifiers=[name_parts] * len(true_names)
+            column_qualifiers=[{ColumnQualifier(tuple(name_parts))} for _ in true_names]
             if source_table_name
             else None,
         )
@@ -94,8 +95,10 @@ def _get_temporary_view(
         spark_column_names=temp_view.column_map.get_spark_columns(),
         snowpark_column_names=snowpark_column_names,
         column_metadata=temp_view.column_map.column_metadata,
-        column_qualifiers=[split_fully_qualified_spark_name(table_name)]
-        * len(temp_view.column_map.get_spark_columns()),
+        column_qualifiers=[
+            {ColumnQualifier(tuple(split_fully_qualified_spark_name(table_name)))}
+            for _ in range(len(temp_view.column_map.get_spark_columns()))
+        ],
         parent_column_name_map=temp_view.column_map.get_parent_column_name_map(),
     )
 

snowflake/snowpark_connect/relation/write/map_write.py

@@ -16,7 +16,7 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     unquote_if_quoted,
 )
 from snowflake.snowpark.exceptions import SnowparkSQLException
-from snowflake.snowpark.functions import col, lit, object_construct, sql_expr
+from snowflake.snowpark.functions import col, lit, object_construct, sql_expr, when
 from snowflake.snowpark.types import (
     ArrayType,
     DataType,
@@ -1083,20 +1083,35 @@ def rewrite_df(input_df: snowpark.DataFrame, source: str) -> snowpark.DataFrame:
         json: construct the dataframe to 1 column in json format
             1. Append columns which represents the column name
             2. Use object_construct to aggregate the dataframe into 1 column
-
+        csv:
+            Use "" to replace empty string
     """
-    if source != "json":
-        return input_df
-    rand_salt = random_string(10, "_")
-    rewritten_df = input_df.with_columns(
-        [co + rand_salt for co in input_df.columns],
-        [lit(unquote_if_quoted(co)) for co in input_df.columns],
-    )
-    construct_key_values = []
-    for co in input_df.columns:
-        construct_key_values.append(col(co + rand_salt))
-        construct_key_values.append(col(co))
-    return rewritten_df.select(object_construct(*construct_key_values))
+    match source:
+        case "json":
+            rand_salt = random_string(10, "_")
+            rewritten_df = input_df.with_columns(
+                [co + rand_salt for co in input_df.columns],
+                [lit(unquote_if_quoted(co)) for co in input_df.columns],
+            )
+            construct_key_values = []
+            for co in input_df.columns:
+                construct_key_values.append(col(co + rand_salt))
+                construct_key_values.append(col(co))
+            return rewritten_df.select(object_construct(*construct_key_values))
+        case "csv":
+            new_cols = []
+            for co in input_df.columns:
+                if isinstance(input_df.schema[co].datatype, StringType):
+                    new_col = col(co)
+                    new_col = when(
+                        new_col.isNotNull() & (new_col == ""), lit('""')
+                    ).otherwise(new_col)
+                    new_cols.append(new_col.alias(co))
+                else:
+                    new_cols.append(col(co))
+            return input_df.select(new_cols)
+        case _:
+            return input_df
 
 
 def handle_column_names(

snowflake/snowpark_connect/server.py

@@ -158,9 +158,8 @@ def _handle_exception(context, e: Exception):
         logger.error("Error: %s - %s", type(e).__name__, str(e))
 
     telemetry.report_request_failure(e)
-
     if tcm.TCM_MODE:
-        # TODO: SNOW-2009834 gracefully return error back in TCM
+        # spark decoder will catch the error and return it to GS gracefully
         attach_custom_error_code(e, ErrorCodes.INTERNAL_ERROR)
         raise e
 

snowflake/snowpark_connect/type_mapping.py

@@ -582,11 +582,14 @@ def map_snowpark_types_to_pyarrow_types(
                 attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_TYPE)
                 raise exception
         case snowpark.types.TimestampType:
-            unit = pa_type.unit
-            tz = pa_type.tz
+            # Check if pa_type has unit attribute (it should be a timestamp type)
+            unit = pa_type.unit if hasattr(pa_type, "unit") else "us"
+            tz = pa_type.tz if hasattr(pa_type, "tz") else None
+
+            # Spark truncates nanosecond precision to microseconds
             if unit == "ns":
-                # Spark truncates nanosecond precision to microseconds
                 unit = "us"
+
             return pa.timestamp(unit, tz=tz)
         case snowpark.types.VariantType:
             return pa.string()
@@ -670,6 +673,9 @@ def map_pyarrow_to_snowpark_types(pa_type: pa.DataType) -> snowpark.types.DataTy
         return snowpark.types.TimestampType()
     elif pa.types.is_null(pa_type):
         return snowpark.types.NullType()
+    elif pa.types.is_duration(pa_type):
+        # Map PyArrow duration[us] to DayTimeIntervalType
+        return snowpark.types.DayTimeIntervalType()
     else:
         exception = SnowparkConnectNotImplementedError(
             f"Unsupported PyArrow data type: {pa_type}"
@@ -892,6 +898,33 @@ def map_simple_types(simple_type: str) -> snowpark.types.DataType:
             return snowpark.types.YearMonthIntervalType()
         case type_name if _INTERVAL_DAYTIME_PATTERN_RE.match(type_name):
             return snowpark.types.DayTimeIntervalType()
+        # Year-Month interval cases
+        case "interval year":
+            return snowpark.types.YearMonthIntervalType(0)
+        case "interval month":
+            return snowpark.types.YearMonthIntervalType(1)
+        case "interval year to month":
+            return snowpark.types.YearMonthIntervalType(0, 1)
+        case "interval day":
+            return snowpark.types.DayTimeIntervalType(0)
+        case "interval hour":
+            return snowpark.types.DayTimeIntervalType(1)
+        case "interval minute":
+            return snowpark.types.DayTimeIntervalType(2)
+        case "interval second":
+            return snowpark.types.DayTimeIntervalType(3)
+        case "interval day to hour":
+            return snowpark.types.DayTimeIntervalType(0, 1)
+        case "interval day to minute":
+            return snowpark.types.DayTimeIntervalType(0, 2)
+        case "interval day to second":
+            return snowpark.types.DayTimeIntervalType(0, 3)
+        case "interval hour to minute":
+            return snowpark.types.DayTimeIntervalType(1, 2)
+        case "interval hour to second":
+            return snowpark.types.DayTimeIntervalType(1, 3)
+        case "interval minute to second":
+            return snowpark.types.DayTimeIntervalType(2, 3)
         case _:
             if simple_type.startswith("decimal"):
                 precision = int(simple_type.split("(")[1].split(",")[0])

snowflake/snowpark_connect/typed_column.py

@@ -8,6 +8,7 @@ from functools import cached_property
 import snowflake.snowpark.functions as snowpark_fn
 from snowflake import snowpark
 from snowflake.snowpark.column import Column
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 
 _EMPTY_COLUMN = Column("")
 
@@ -44,11 +45,11 @@ class TypedColumn:
     def alias(self, alias_name: str):
         return TypedColumn(self.col.alias(alias_name), self._type_resolver)
 
-    def set_qualifiers(self, qualifiers: list[str]):
+    def set_qualifiers(self, qualifiers: set[ColumnQualifier]) -> None:
         self.qualifiers = qualifiers
 
-    def get_qualifiers(self) -> list[str]:
-        return getattr(self, "qualifiers", [])
+    def get_qualifiers(self) -> set[ColumnQualifier]:
+        return getattr(self, "qualifiers", {ColumnQualifier.no_qualifier()})
 
     def set_catalog_database_info(self, catalog_database_info: dict[str, str]) -> None:
         self._catalog_database_info = catalog_database_info
@@ -63,12 +64,13 @@ class TypedColumn:
     def get_database(self) -> str | None:
         return self._catalog_database_info.get("database")
 
-    def set_multi_col_qualifiers(self, qualifiers: list[list[str]]):
+    def set_multi_col_qualifiers(self, qualifiers: list[set[ColumnQualifier]]) -> None:
         self.multi_col_qualifiers = qualifiers
 
-    def get_multi_col_qualifiers(self, num_columns) -> list[list[str]]:
+    def get_multi_col_qualifiers(self, num_columns) -> list[set[ColumnQualifier]]:
         if not hasattr(self, "multi_col_qualifiers"):
-            return [[] for i in range(num_columns)]
+
+            return [{ColumnQualifier.no_qualifier()} for i in range(num_columns)]
         assert (
             len(self.multi_col_qualifiers) == num_columns
         ), f"Expected {num_columns} multi-column qualifiers, got {len(self.multi_col_qualifiers)}"

snowflake/snowpark_connect/utils/session.py

@@ -23,6 +23,13 @@ from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.utils.telemetry import telemetry
 from snowflake.snowpark_connect.utils.udf_cache import init_builtin_udf_cache
 
+SKIP_SESSION_CONFIGURATION = False
+
+
+def skip_session_configuration(skip: bool):
+    global SKIP_SESSION_CONFIGURATION
+    SKIP_SESSION_CONFIGURATION = skip
+
 
 # Suppress experimental warnings from snowflake.snowpark logger
 def _filter_experimental_warnings(record):
@@ -57,6 +64,8 @@ def configure_snowpark_session(session: snowpark.Session):
         global_config,
     )
 
+    global SKIP_SESSION_CONFIGURATION
+
     logger.info(f"Configuring session {session}")
 
     telemetry.initialize(session)
@@ -124,9 +133,16 @@ def configure_snowpark_session(session: snowpark.Session):
         "QUERY_TAG": f"'{query_tag}'",
     }
 
-    session.sql(
-        f"ALTER SESSION SET {', '.join([f'{k} = {v}' for k, v in session_params.items()])}"
-    ).collect()
+    # SNOW-2245971: Stored procedures inside Native Apps run as Execute As Owner and hence cannot set session params.
+    if not SKIP_SESSION_CONFIGURATION:
+        session.sql(
+            f"ALTER SESSION SET {', '.join([f'{k} = {v}' for k, v in session_params.items()])}"
+        ).collect()
+    else:
+        session_param_names = ", ".join(session_params.keys())
+        logger.info(
+            f"Skipping Snowpark Connect session configuration as requested. Please make sure following session parameters are set correctly: {session_param_names}"
+        )
 
     # Instrument the snowpark session to use a cache for describe queries.
     instrument_session_for_describe_cache(session)

snowflake/snowpark_connect/version.py

@@ -2,4 +2,4 @@
 #
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
-VERSION = (0,31,0)
+VERSION = (0,32,0)

snowflake/snowpark_decoder/dp_session.py

@@ -107,5 +107,5 @@ class DataframeProcessorSession:
             )
             return proto2str(dp_res_proto)
         except Exception:
-            # TODO: SNOW-1857056 error handling
+            # raise the error to GS
             raise

{snowpark_connect-0.31.0.dist-info → snowpark_connect-0.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.31.0
+Version: 0.32.0
 Summary: Snowpark Connect for Spark
 Author: Snowflake, Inc
 License: Apache License, Version 2.0
@@ -13,7 +13,7 @@ Requires-Dist: certifi>=2025.1.31
 Requires-Dist: cloudpickle
 Requires-Dist: fsspec[http]
 Requires-Dist: jpype1
-Requires-Dist: protobuf<5.0,>=4.25.3
+Requires-Dist: protobuf<6.32.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.41.0,==1.40.0
@@ -29,11 +29,14 @@ Requires-Dist: grpcio-status<1.63,>=1.56.0
 Requires-Dist: googleapis-common-protos>=1.56.4
 Requires-Dist: numpy<2,>=1.15
 Requires-Dist: gcsfs>=2025.9.0
+Provides-Extra: jdk
+Requires-Dist: jdk4py==17.0.9.2; extra == "jdk"
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary