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

snowflake/snowpark_connect/__init__.py

@@ -10,6 +10,7 @@ sys.path.append(str(pathlib.Path(__file__).parent / "includes/python"))
 
 from .server import get_session  # noqa: E402, F401
 from .server import start_session  # noqa: E402, F401
+from .utils.session import skip_session_configuration  # noqa: E402, F401
 
 # Turn off catalog warning for Snowpark
 sp_logger = logging.getLogger("snowflake.snowpark")

snowflake/snowpark_connect/column_name_handler.py

@@ -13,12 +13,10 @@ from functools import cached_property
 from pyspark.errors.exceptions.base import AnalysisException
 
 from snowflake.snowpark import DataFrame
-from snowflake.snowpark._internal.analyzer.analyzer_utils import (
-    quote_name_without_upper_casing,
-    unquote_if_quoted,
-)
+from snowflake.snowpark._internal.analyzer.analyzer_utils import unquote_if_quoted
 from snowflake.snowpark._internal.utils import quote_name
 from snowflake.snowpark.types import StructType
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.error.error_codes import ErrorCodes
 from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
@@ -97,31 +95,15 @@ def make_column_names_snowpark_compatible(
 class ColumnNames:
     spark_name: str
     snowpark_name: str
-    qualifiers: list[str]
+    qualifiers: set[ColumnQualifier]
     catalog_info: str | None = None  # Catalog from fully qualified name
     database_info: str | None = None  # Database from fully qualified name
 
-
-def get_list_of_spark_names_for_column(column_names: ColumnNames) -> list[str]:
-    """
-    Returns a list of Spark names for a given ColumnNames object.
-    This is useful when a single Spark name maps to multiple names due to table alias.
-
-    For example, if the column name is 'id' and the qualifiers are ['db', 'table'],
-    then the possible Spark names are:
-      ['id', 'db.table.id', 'table.id']
-    """
-    spark_name = column_names.spark_name
-    qualifiers = column_names.qualifiers
-
-    qualifier_suffixes_list = [
-        ".".join(quote_name_without_upper_casing(x) for x in qualifiers[i:])
-        for i in range(len(qualifiers))
-    ]
-    return [spark_name] + [
-        f"{qualifier_suffix}.{spark_name}"
-        for qualifier_suffix in qualifier_suffixes_list
-    ]
+    def all_spark_names_including_qualified_names(self):
+        all_names = [self.spark_name]
+        for qualifier in self.qualifiers:
+            all_names.extend(qualifier.all_qualified_names(self.spark_name))
+        return all_names
 
 
 class ColumnNameMap:
@@ -133,13 +115,13 @@ class ColumnNameMap:
             [], bool
         ] = lambda: global_config.spark_sql_caseSensitive,
         column_metadata: dict | None = None,
-        column_qualifiers: list[list[str]] | None = None,
+        column_qualifiers: list[set[ColumnQualifier]] = None,
         parent_column_name_map: ColumnNameMap | None = None,
     ) -> None:
         """
         spark_column_names: Original spark column names
         snowpark_column_names: Snowpark column names
-        column_metadata: This field is used to store metadata related to columns. Since Snowpark’s Struct type does not support metadata,
+        column_metadata: This field is used to store metadata related to columns. Since Snowpark's Struct type does not support metadata,
         we use this attribute to store any metadata related to the columns.
         The key is the original Spark column name, and the value is the metadata.
         example: Dict('age', {'foo': 'bar'})
@@ -186,21 +168,18 @@ class ColumnNameMap:
             c = ColumnNames(
                 spark_name=spark_name,
                 snowpark_name=snowpark_column_names[i],
-                qualifiers=column_qualifiers[i] if column_qualifiers else [],
+                qualifiers=column_qualifiers[i]
+                if column_qualifiers and column_qualifiers[i]
+                else {ColumnQualifier.no_qualifier()},
                 catalog_info=catalog_info,
                 database_info=database_info,
             )
             self.columns.append(c)
 
-            # we want to store all the spark names including qualifiers (these are generated from table alias or dataframe alias)
-            spark_names_including_qualifier = get_list_of_spark_names_for_column(c)
-
-            for spark_name_including_qualifier in spark_names_including_qualifier:
+            for spark_name in c.all_spark_names_including_qualified_names():
                 # the same spark name can map to multiple snowpark names
-                self.spark_to_col[spark_name_including_qualifier].append(c)
-                self.uppercase_spark_to_col[
-                    spark_name_including_qualifier.upper()
-                ].append(c)
+                self.spark_to_col[spark_name].append(c)
+                self.uppercase_spark_to_col[spark_name.upper()].append(c)
 
             # the same snowpark name can map to multiple spark column
             # e.g. df.select(date_format('dt', 'yyy'), date_format('dt', 'yyyy')) ->
@@ -405,7 +384,7 @@ class ColumnNameMap:
         if spark_column_name not in self.spark_to_col:
             return False
 
-        columns = self.spark_to_col[spark_column_name]
+        columns: list[ColumnNames] = self.spark_to_col[spark_column_name]
 
         # If we don't have multiple columns, there's no ambiguity to resolve
         if len(columns) <= 1:
@@ -416,30 +395,7 @@ class ColumnNameMap:
         first_column = columns[0]
 
         for column in columns[1:]:
-            # Check snowpark_type attribute
-            # If one has the attribute but the other doesn't, they're different
-            if hasattr(first_column, "snowpark_type") != hasattr(
-                column, "snowpark_type"
-            ):
-                return False
-            # If both have the attribute and values differ, they're different expressions
-            if (
-                hasattr(first_column, "snowpark_type")
-                and hasattr(column, "snowpark_type")
-                and first_column.snowpark_type != column.snowpark_type
-            ):
-                return False
-
-            # Check qualifiers attribute
-            # If one has the attribute but the other doesn't, they're different
-            if hasattr(first_column, "qualifiers") != hasattr(column, "qualifiers"):
-                return False
-            # If both have the attribute and values differ, they might be from different contexts
-            if (
-                hasattr(first_column, "qualifiers")
-                and hasattr(column, "qualifiers")
-                and first_column.qualifiers != column.qualifiers
-            ):
+            if first_column.qualifiers != column.qualifiers:
                 return False
 
         # Additional safety check: ensure all snowpark names are actually in our mapping
@@ -500,32 +456,30 @@ class ColumnNameMap:
         return [c.spark_name for c in self.columns]
 
     def get_spark_and_snowpark_columns_with_qualifier_for_qualifier(
-        self, qualifiers_input: list[str]
-    ) -> tuple[list[str], list[str], list[list[str]]]:
+        self, target_qualifier: ColumnQualifier
+    ) -> tuple[list[str], list[str], list[set[ColumnQualifier]]]:
         """
-        Returns the Spark and Snowpark column names along with their qualifiers for the specified qualifiers.
-        If a column does not have a qualifier, it will be None.
+        Returns the Spark and Snowpark column names along with their qualifiers for the specified qualifier.
         """
-        spark_columns = []
-        snowpark_columns = []
-        qualifiers = []
+        spark_columns: list[str] = []
+        snowpark_columns: list[str] = []
+        qualifiers: list[set[ColumnQualifier]] = []
 
+        normalized_qualifier = target_qualifier
         if not self.is_case_sensitive():
-            qualifiers_input = [q.upper() for q in qualifiers_input]
+            normalized_qualifier = target_qualifier.to_upper()
 
-        for c in self.columns:
-            col_qualifiers = (
-                [q.upper() for q in c.qualifiers]
+        for column in self.columns:
+            # Normalize all qualifiers for comparison
+            column_qualifiers: set[ColumnQualifier] = (
+                {q.to_upper() for q in iter(column.qualifiers)}
                 if not self.is_case_sensitive()
-                else c.qualifiers
+                else column.qualifiers
             )
-            if len(col_qualifiers) < len(qualifiers_input):
-                # If the column has fewer qualifiers than the input, it cannot match
-                continue
-            if col_qualifiers[-len(qualifiers_input) :] == qualifiers_input:
-                spark_columns.append(c.spark_name)
-                snowpark_columns.append(c.snowpark_name)
-                qualifiers.append(c.qualifiers)
+            if any([q.matches(normalized_qualifier) for q in column_qualifiers]):
+                spark_columns.append(column.spark_name)
+                snowpark_columns.append(column.snowpark_name)
+                qualifiers.append(column.qualifiers)
 
         return spark_columns, snowpark_columns, qualifiers
 
@@ -539,19 +493,17 @@ class ColumnNameMap:
             if self._quote_if_unquoted(c) not in cols_to_drop
         ]
 
-    def get_qualifiers(self) -> list[list[str]]:
+    def get_qualifiers(self) -> list[set[ColumnQualifier]]:
         """
         Returns the qualifiers for the columns.
-        If a column does not have a qualifier, it will be None.
         """
         return [c.qualifiers for c in self.columns]
 
     def get_qualifiers_for_columns_after_drop(
         self, cols_to_drop: list[str]
-    ) -> list[list[str]]:
+    ) -> list[set[ColumnQualifier]]:
         """
         Returns the qualifiers for the columns after dropping the specified columns.
-        If a column is dropped, its qualifier will be None.
         """
         return [
             c.qualifiers
@@ -562,10 +514,25 @@ class ColumnNameMap:
     def get_qualifier_for_spark_column(
         self,
         spark_column_name: str,
-    ) -> list[str]:
+    ) -> ColumnQualifier:
+        """
+        Backward compatibility: returns the first qualifier for the given Spark column name.
+        Throws if more than one qualifier exists.
+        """
+        qualifiers = self.get_qualifiers_for_spark_column(spark_column_name)
+        if len(qualifiers) > 1:
+            raise ValueError(
+                "Shouldn't happen. Multiple qualifiers found; expected only one."
+            )
+        return next(iter(qualifiers))
+
+    def get_qualifiers_for_spark_column(
+        self,
+        spark_column_name: str,
+    ) -> set[ColumnQualifier]:
         """
         Returns the qualifier for the specified Spark column name.
-        If the column does not exist, returns None.
+        If the column does not exist, returns empty ColumnQualifier.
         """
         if not self.is_case_sensitive():
             name = spark_column_name.upper()
@@ -577,7 +544,7 @@ class ColumnNameMap:
         col = mapping.get(name)
 
         if col is None or len(col) == 0:
-            return []
+            return {ColumnQualifier.no_qualifier()}
 
         return col[0].qualifiers
 
@@ -609,7 +576,7 @@ class ColumnNameMap:
 
     def with_columns(
         self, new_spark_columns: list[str], new_snowpark_columns: list[str]
-    ) -> tuple[list[str], list[str], list[list[str]]]:
+    ) -> tuple[list[str], list[str], list[set[ColumnQualifier]]]:
         """
         Returns an ordered list of spark and snowpark column names after adding the new columns through a withColumns call.
         All replaced columns retain their ordering in the dataframe. The new columns are added to the end of the list.
@@ -638,7 +605,7 @@ class ColumnNameMap:
                 removed_index.add(index)
                 spark_columns.append(new_spark_columns[index])
                 snowpark_columns.append(new_snowpark_columns[index])
-                qualifiers.append([])
+                qualifiers.append({ColumnQualifier.no_qualifier()})
             else:
                 spark_columns.append(c.spark_name)
                 snowpark_columns.append(c.snowpark_name)
@@ -648,7 +615,7 @@ class ColumnNameMap:
             if i not in removed_index:
                 spark_columns.append(new_spark_columns[i])
                 snowpark_columns.append(new_snowpark_columns[i])
-                qualifiers.append([])
+                qualifiers.append({ColumnQualifier.no_qualifier()})
 
         return spark_columns, snowpark_columns, qualifiers
 
@@ -745,7 +712,9 @@ class JoinColumnNameMap(ColumnNameMap):
         raise exception
 
     def get_spark_column_name_from_snowpark_column_name(
-        self, snowpark_column_name: str
+        self,
+        snowpark_column_name: str,
+        allow_non_exists: bool = False,
     ) -> str:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
@@ -788,32 +757,36 @@ class JoinColumnNameMap(ColumnNameMap):
 
     def with_columns(
         self, new_spark_columns: list[str], new_snowpark_columns: list[str]
-    ) -> tuple[list[str], list[str], list[list[str]]]:
+    ) -> tuple[list[str], list[str], list[set[ColumnQualifier]]]:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
         raise exception
 
-    def get_qualifiers(self) -> list[list[str]]:
+    def get_qualifiers(self) -> list[set[ColumnQualifier]]:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
         raise exception
 
     def get_qualifiers_for_columns_after_drop(
         self, cols_to_drop: list[str]
-    ) -> list[list[str]]:
+    ) -> list[set[ColumnQualifier]]:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
         raise exception
 
     def get_spark_and_snowpark_columns_with_qualifier_for_qualifier(
-        self, qualifiers_input: list[str]
-    ) -> tuple[list[str], list[str], list[list[str]]]:
+        self, target_qualifier: list[str]
+    ) -> tuple[list[str], list[str], list[set[ColumnQualifier]]]:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
         raise exception
 
-    def get_qualifier_for_spark_column(self, spark_column_name: str) -> list[str]:
+    def get_qualifiers_for_spark_column(
+        self, spark_column_name: str
+    ) -> set[ColumnQualifier]:
+        return {self.get_qualifier_for_spark_column(spark_column_name)}
 
+    def get_qualifier_for_spark_column(self, spark_column_name: str) -> ColumnQualifier:
         qualifier_left = self.left_column_mapping.get_qualifier_for_spark_column(
             spark_column_name
         )
@@ -821,9 +794,9 @@ class JoinColumnNameMap(ColumnNameMap):
             spark_column_name
         )
 
-        if (len(qualifier_left) > 0) and (len(qualifier_right) > 0):
+        if (not qualifier_left.is_empty) and (not qualifier_right.is_empty):
             exception = AnalysisException(f"Ambiguous column name {spark_column_name}")
             attach_custom_error_code(exception, ErrorCodes.AMBIGUOUS_COLUMN_NAME)
             raise exception
 
-        return qualifier_right if len(qualifier_left) == 0 else qualifier_left
+        return qualifier_right if qualifier_left.is_empty else qualifier_left

snowflake/snowpark_connect/column_qualifier.py

@@ -0,0 +1,47 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from snowflake.snowpark._internal.analyzer.analyzer_utils import (
+    quote_name_without_upper_casing,
+)
+
+
+@dataclass(frozen=True)
+class ColumnQualifier:
+    parts: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if not all(isinstance(x, str) for x in self.parts):
+            raise TypeError("ColumnQualifier.parts must be strings")
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.parts) == 0
+
+    @classmethod
+    def no_qualifier(cls) -> ColumnQualifier:
+        return cls(())
+
+    def all_qualified_names(self, name: str) -> list[str]:
+        qualifier_parts = self.parts
+        qualifier_prefixes = [
+            ".".join(quote_name_without_upper_casing(x) for x in qualifier_parts[i:])
+            for i in range(len(qualifier_parts))
+        ]
+        return [f"{prefix}.{name}" for prefix in qualifier_prefixes]
+
+    def to_upper(self):
+        return ColumnQualifier(tuple(part.upper() for part in self.parts))
+
+    def matches(self, target: ColumnQualifier) -> bool:
+        if self.is_empty or target.is_empty:
+            return False
+        # If the column has fewer qualifiers than the target, it cannot match
+        if len(self.parts) < len(target.parts):
+            return False
+        return self.parts[-len(target.parts) :] == target.parts

snowflake/snowpark_connect/dataframe_container.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Callable
 
 from snowflake import snowpark
 from snowflake.snowpark.types import StructField, StructType
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 
 if TYPE_CHECKING:
     from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
@@ -58,7 +59,7 @@ class DataFrameContainer:
         snowpark_column_names: list[str],
         snowpark_column_types: list | None = None,
         column_metadata: dict | None = None,
-        column_qualifiers: list[list[str]] | None = None,
+        column_qualifiers: list[set[ColumnQualifier]] | None = None,
         parent_column_name_map: ColumnNameMap | None = None,
         table_name: str | None = None,
         alias: str | None = None,
@@ -220,7 +221,7 @@ class DataFrameContainer:
         spark_column_names: list[str],
         snowpark_column_names: list[str],
         column_metadata: dict | None = None,
-        column_qualifiers: list[list[str]] | None = None,
+        column_qualifiers: list[set[ColumnQualifier]] | None = None,
         parent_column_name_map: ColumnNameMap | None = None,
     ) -> ColumnNameMap:
         """Create a ColumnNameMap with the provided configuration."""

snowflake/snowpark_connect/execute_plan/map_execution_command.py

@@ -54,9 +54,11 @@ def _create_column_rename_map(
             new_column_name = (
                 f"{new_column_name}_DEDUP_{column_counts[normalized_name] - 1}"
             )
-            renamed_cols.append(ColumnNames(new_column_name, col.snowpark_name, []))
+            renamed_cols.append(ColumnNames(new_column_name, col.snowpark_name, set()))
         else:
-            not_renamed_cols.append(ColumnNames(new_column_name, col.snowpark_name, []))
+            not_renamed_cols.append(
+                ColumnNames(new_column_name, col.snowpark_name, set())
+            )
 
     if len(renamed_cols) == 0:
         return {

snowflake/snowpark_connect/expression/map_expression.py

@@ -230,18 +230,18 @@ def map_expression(
                     | exp.sort_order.SORT_DIRECTION_ASCENDING
                 ):
                     if exp.sort_order.null_ordering == exp.sort_order.SORT_NULLS_LAST:
-                        return [child_name], snowpark_fn.asc_nulls_last(child_column)
+                        col = snowpark_fn.asc_nulls_last(child_column.col)
                     else:
                         # If nulls are not specified or null_ordering is FIRST in the sort order, Spark defaults to nulls
                         # first in the case of ascending sort order.
-                        return [child_name], snowpark_fn.asc_nulls_first(child_column)
+                        col = snowpark_fn.asc_nulls_first(child_column.col)
                 case exp.sort_order.SORT_DIRECTION_DESCENDING:
                     if exp.sort_order.null_ordering == exp.sort_order.SORT_NULLS_FIRST:
-                        return [child_name], snowpark_fn.desc_nulls_first(child_column)
+                        col = snowpark_fn.desc_nulls_first(child_column.col)
                     else:
                         # If nulls are not specified or null_ordering is LAST in the sort order, Spark defaults to nulls
                         # last in the case of descending sort order.
-                        return [child_name], snowpark_fn.desc_nulls_last(child_column)
+                        col = snowpark_fn.desc_nulls_last(child_column.col)
                 case _:
                     exception = ValueError(
                         f"Invalid sort direction {exp.sort_order.direction}"
@@ -250,6 +250,7 @@ def map_expression(
                         exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
                     )
                     raise exception
+            return [child_name], TypedColumn(col, lambda: typer.type(col))
         case "unresolved_attribute":
             col_name, col = map_att.map_unresolved_attribute(exp, column_mapping, typer)
             # Check if this is a multi-column regex expansion

snowflake/snowpark_connect/expression/map_extension.py

@@ -277,6 +277,9 @@ def _format_day_time_interval(
     if is_negative:
         days = -days
 
+    # Calculate days string representation (handle -0 case)
+    days_str = "-0" if (is_negative and days == 0) else str(days)
+
     # Format based on the specific start/end field context
     if (
         start_field == DayTimeIntervalType.DAY and end_field == DayTimeIntervalType.DAY
@@ -344,7 +347,10 @@ def _format_day_time_interval(
         start_field == DayTimeIntervalType.HOUR
         and end_field == DayTimeIntervalType.MINUTE
     ):  # HOUR TO MINUTE
-        str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(hours)}:{_TWO_DIGIT_FORMAT.format(minutes)}' HOUR TO MINUTE"
+        if is_negative:
+            str_value = f"INTERVAL '-{_TWO_DIGIT_FORMAT.format(hours)}:{_TWO_DIGIT_FORMAT.format(minutes)}' HOUR TO MINUTE"
+        else:
+            str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(hours)}:{_TWO_DIGIT_FORMAT.format(minutes)}' HOUR TO MINUTE"
     elif (
         start_field == DayTimeIntervalType.HOUR
         and end_field == DayTimeIntervalType.SECOND
@@ -368,21 +374,21 @@ def _format_day_time_interval(
         and end_field == DayTimeIntervalType.SECOND
     ):  # DAY TO SECOND
         if seconds == int(seconds):
-            str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
+            str_value = f"INTERVAL '{days_str} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
         else:
             seconds_str = _format_seconds_precise(seconds)
-            str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
+            str_value = f"INTERVAL '{days_str} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
     else:
         # Fallback - use smart formatting like the original literal.py logic
-        if days > 0:
+        if days >= 0:
             if hours == 0 and minutes == 0 and seconds == 0:
                 str_value = f"INTERVAL '{int(days)}' DAY"
             else:
                 if seconds == int(seconds):
-                    str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
+                    str_value = f"INTERVAL '{days_str} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
                 else:
                     seconds_str = _format_seconds_precise(seconds)
-                    str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
+                    str_value = f"INTERVAL '{days_str} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
         elif hours > 0:
             if minutes == 0 and seconds == 0:
                 str_value = f"INTERVAL '{_format_time_component(hours)}' HOUR"

snowflake/snowpark_connect/expression/map_sql_expression.py

@@ -260,12 +260,47 @@ def map_logical_plan_expression(exp: jpype.JObject) -> expressions_proto.Express
     class_name = str(exp.getClass().getSimpleName())
     match class_name:
         case "AggregateExpression":
-            func_name = as_java_list(exp.children())[0].nodeName()
+            aggregate_func = as_java_list(exp.children())[0]
+            func_name = aggregate_func.nodeName()
             args = [
                 map_logical_plan_expression(e)
-                for e in list(as_java_list(as_java_list(exp.children())[0].children()))
+                for e in list(as_java_list(aggregate_func.children()))
             ]
-            proto = apply_filter_clause(func_name, args, exp)
+
+            # Special handling for percentile_cont and percentile_disc
+            # These functions have a 'reverse' property that indicates sort order
+            # Pass it as a 3rd argument (sort_order expression) without modifying children
+            if func_name.lower() in ("percentile_cont", "percentiledisc"):
+                # percentile_cont/disc should always have exactly 2 children: unresolved attribute and percentile value
+                if len(args) != 2:
+                    exception = AssertionError(
+                        f"{func_name} expected 2 args but got {len(args)}"
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                    raise exception
+
+                reverse = bool(aggregate_func.reverse())
+
+                direction = (
+                    expressions_proto.Expression.SortOrder.SORT_DIRECTION_DESCENDING
+                    if reverse
+                    else expressions_proto.Expression.SortOrder.SORT_DIRECTION_ASCENDING
+                )
+
+                sort_order_expr = expressions_proto.Expression(
+                    sort_order=expressions_proto.Expression.SortOrder(
+                        child=args[0],
+                        direction=direction,
+                    )
+                )
+                args.append(sort_order_expr)
+                proto = apply_filter_clause(func_name, [args[0]], exp)
+                # second arg is a literal value and it doesn't make sense to apply filter on it.
+                # also skips filtering on sort_order.
+                proto.unresolved_function.arguments.append(args[1])
+                proto.unresolved_function.arguments.append(sort_order_expr)
+            else:
+                proto = apply_filter_clause(func_name, args, exp)
         case "Alias":
             proto = expressions_proto.Expression(
                 alias=expressions_proto.Expression.Alias(

snowflake/snowpark_connect/expression/map_unresolved_attribute.py

@@ -247,7 +247,7 @@ def map_unresolved_attribute(
                 )
             )
             col = get_col(snowpark_name)
-            qualifiers = column_mapping.get_qualifier_for_spark_column(quoted_col_name)
+            qualifiers = column_mapping.get_qualifiers_for_spark_column(quoted_col_name)
             typed_col = TypedColumn(col, lambda: typer.type(col))
             typed_col.set_qualifiers(qualifiers)
             # Store matched columns info for later use
@@ -262,7 +262,7 @@ def map_unresolved_attribute(
                 )
             )
             col = get_col(snowpark_name)
-            qualifiers = column_mapping.get_qualifier_for_spark_column(quoted_col_name)
+            qualifiers = column_mapping.get_qualifiers_for_spark_column(quoted_col_name)
             typed_col = TypedColumn(col, lambda: typer.type(col))
             typed_col.set_qualifiers(qualifiers)
             return (matched_columns[0], typed_col)
@@ -280,7 +280,7 @@ def map_unresolved_attribute(
     )
     if snowpark_name is not None:
         col = get_col(snowpark_name)
-        qualifiers = column_mapping.get_qualifier_for_spark_column(quoted_attr_name)
+        qualifiers = column_mapping.get_qualifiers_for_spark_column(quoted_attr_name)
     else:
         # this means it has to be a struct column with a field name
         snowpark_name: str | None = None
@@ -338,7 +338,7 @@ def map_unresolved_attribute(
                 )
                 if snowpark_name is not None:
                     col = get_col(snowpark_name)
-                    qualifiers = column_mapping.get_qualifier_for_spark_column(
+                    qualifiers = column_mapping.get_qualifiers_for_spark_column(
                         unqualified_name
                     )
                     typed_col = TypedColumn(col, lambda: typer.type(col))
@@ -405,7 +405,7 @@ def map_unresolved_attribute(
         for field_name in path:
             col = col.getItem(field_name)
 
-        qualifiers = []
+        qualifiers = set()
 
     typed_col = TypedColumn(col, lambda: typer.type(col))
     typed_col.set_qualifiers(qualifiers)