snowpark-connect 0.27.0__tar.gz → 0.28.0__tar.gz

{snowpark_connect-0.27.0/src/snowpark_connect.egg-info → snowpark_connect-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.27.0
+Version: 0.28.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.39.0,==1.38.0
+Requires-Dist: snowflake-snowpark-python[pandas]<1.40.0,==1.39.0
 Requires-Dist: sqlglot>=26.3.8
 Requires-Dist: jaydebeapi
 Requires-Dist: aiobotocore~=2.23.0

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/setup.py

@@ -46,7 +46,7 @@ setup(
         "protobuf>=4.25.3,<5.0",
         "s3fs>=2025.3.0",  # prod-297255-inc0132291
         "snowflake.core>=1.0.5,<2",
-        "snowflake-snowpark-python[pandas]==1.38.0,<1.39.0",
+        "snowflake-snowpark-python[pandas]==1.39.0,<1.40.0",
         "sqlglot>=26.3.8",
         "jaydebeapi",
         "aiobotocore~=2.23.0",

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/column_name_handler.py

@@ -20,7 +20,6 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
 from snowflake.snowpark._internal.utils import quote_name
 from snowflake.snowpark.types import StructType
 from snowflake.snowpark_connect.config import global_config
-from snowflake.snowpark_connect.hidden_column import HiddenColumn
 from snowflake.snowpark_connect.utils.context import get_current_operation_scope
 from snowflake.snowpark_connect.utils.identifiers import (
     split_fully_qualified_spark_name,
@@ -124,7 +123,6 @@ class ColumnNameMap:
         ] = lambda: global_config.spark_sql_caseSensitive,
         column_metadata: dict | None = None,
         column_qualifiers: list[list[str]] | None = None,
-        hidden_columns: set[HiddenColumn] | None = None,
         parent_column_name_map: ColumnNameMap | None = None,
     ) -> None:
         """
@@ -135,7 +133,6 @@ class ColumnNameMap:
         The key is the original Spark column name, and the value is the metadata.
         example: Dict('age', {'foo': 'bar'})
         column_qualifiers: Optional qualifiers for the columns, used to handle table aliases or DataFrame aliases.
-        hidden_columns: Optional set of HiddenColumn objects.
         parent_column_name_map: parent ColumnNameMap
         """
         self.columns: list[ColumnNames] = []
@@ -144,7 +141,6 @@ class ColumnNameMap:
         self.snowpark_to_col = defaultdict(list)
         self.is_case_sensitive = is_case_sensitive
         self.column_metadata = column_metadata
-        self.hidden_columns = hidden_columns
 
         # Rename chain dictionary to track column renaming history
         self.rename_chains: dict[str, str] = {}  # old_name -> new_name mapping
@@ -338,8 +334,6 @@ class ColumnNameMap:
         *,
         allow_non_exists: bool = False,
         return_first: bool = False,
-        is_qualified: bool = False,
-        source_qualifiers: list[str] | None = None,
     ) -> str | None:
         assert isinstance(spark_column_name, str)
         resolved_name = (
@@ -347,37 +341,9 @@ class ColumnNameMap:
             if self.rename_chains
             else spark_column_name
         )
-
-        # We need to check hidden columns first. We want to avoid the code path
-        # within get_snowpark_column_names_from_spark_column_names that checks the parent ColumnNameMap.
-        # This is because that will return the name of the using column that's been dropped from the result
-        # dataframe. We want to fetch and resolve the hidden column to its visible using column name instead.
-        # Even if this is an unqualified reference or one to the visible column, it will resolve correctly to
-        # the visible name anyway.
-        snowpark_names = []
-        # Only check hidden columns for qualified references with source qualifiers
-        if is_qualified and source_qualifiers is not None and self.hidden_columns:
-            column_name = spark_column_name
-
-            # Check each hidden column for column name AND qualifier match
-            for hidden_col in self.hidden_columns:
-                if (
-                    hidden_col.spark_name == column_name
-                    and hidden_col.qualifiers == source_qualifiers
-                ):
-                    if not global_config.spark_sql_caseSensitive:
-                        if hidden_col.spark_name.upper() == column_name.upper() and [
-                            q.upper() for q in hidden_col.qualifiers
-                        ] == [q.upper() for q in source_qualifiers]:
-                            snowpark_names.append(hidden_col.visible_snowpark_name)
-                    else:
-                        snowpark_names.append(hidden_col.visible_snowpark_name)
-
-        # If not found in hidden columns, proceed with normal lookup
-        if not snowpark_names:
-            snowpark_names = self.get_snowpark_column_names_from_spark_column_names(
-                [resolved_name], return_first
-            )
+        snowpark_names = self.get_snowpark_column_names_from_spark_column_names(
+            [resolved_name], return_first
+        )
 
         snowpark_names_len = len(snowpark_names)
         if snowpark_names_len > 1:
@@ -464,27 +430,6 @@ class ColumnNameMap:
                 snowpark_columns.append(c.snowpark_name)
                 qualifiers.append(c.qualifiers)
 
-        # Note: The following code is commented out because there is a bug with handling duplicate columns in
-        # qualified select *'s. This needs to be revisited once a solution for that is found.
-        # TODO: https://snowflakecomputing.atlassian.net/browse/SNOW-2265240
-
-        # # Handles fetching/resolving the hidden columns if they also match the qualifiers
-        # # This method is only ever called for qualified references, so we need to check hidden columns as well.
-        # if self.hidden_columns:
-        #     for hidden_col in self.hidden_columns:
-        #         col_qualifiers = (
-        #             [q.upper() for q in hidden_col.qualifiers]
-        #             if not self.is_case_sensitive()
-        #             else hidden_col.qualifiers
-        #         )
-        #         if len(col_qualifiers) < len(qualifiers_input):
-        #             continue
-        #         if col_qualifiers[-len(qualifiers_input) :] == qualifiers_input:
-        #             # This hidden column matches! Add it to the results
-        #             spark_columns.append(hidden_col.spark_name)
-        #             snowpark_columns.append(hidden_col.visible_snowpark_name)
-        #             qualifiers.append(hidden_col.qualifiers)
-
         return spark_columns, snowpark_columns, qualifiers
 
     def get_snowpark_columns(self) -> list[str]:
@@ -616,35 +561,6 @@ class ColumnNameMap:
         else:
             return spark_name.upper()
 
-    def is_hidden_column_reference(
-        self, spark_column_name: str, source_qualifiers: list[str] | None = None
-    ) -> bool:
-        """
-        Check if a column reference would be resolved through hidden columns.
-        """
-        if not self.hidden_columns or source_qualifiers is None:
-            return False
-
-        # For qualified references with source_qualifiers
-        column_name = (
-            spark_column_name  # When has_plan_id=True, this is just the column name
-        )
-
-        for hidden_col in self.hidden_columns:
-            if (
-                hidden_col.spark_name == column_name
-                and hidden_col.qualifiers == source_qualifiers
-            ):
-                if not global_config.spark_sql_caseSensitive:
-                    if hidden_col.spark_name.upper() == column_name.upper() and [
-                        q.upper() for q in hidden_col.qualifiers
-                    ] == [q.upper() for q in source_qualifiers]:
-                        return True
-                else:
-                    return True
-
-        return False
-
 
 class JoinColumnNameMap(ColumnNameMap):
     def __init__(
@@ -654,9 +570,6 @@ class JoinColumnNameMap(ColumnNameMap):
     ) -> None:
         self.left_column_mapping: ColumnNameMap = left_colmap
         self.right_column_mapping: ColumnNameMap = right_colmap
-        # Ensure attributes expected by base-class helpers exist to avoid AttributeError
-        # when generic code paths (e.g., hidden column checks) touch them.
-        self.hidden_columns: set[HiddenColumn] | None = None
 
     def get_snowpark_column_name_from_spark_column_name(
         self,
@@ -664,9 +577,6 @@ class JoinColumnNameMap(ColumnNameMap):
         *,
         allow_non_exists: bool = False,
         return_first: bool = False,
-        # JoinColumnNameMap will never be called with using columns, so these parameters are not used.
-        is_qualified: bool = False,
-        source_qualifiers: list[str] | None = None,
     ) -> str | None:
         snowpark_column_name_in_left = (
             self.left_column_mapping.get_snowpark_column_name_from_spark_column_name(

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/config.py

@@ -8,7 +8,7 @@ import re
 import sys
 from collections import defaultdict
 from copy import copy, deepcopy
-from typing import Any
+from typing import Any, Dict
 
 import jpype
 import pyspark.sql.connect.proto.base_pb2 as proto_base
@@ -17,6 +17,7 @@ from tzlocal import get_localzone_name
 from snowflake import snowpark
 from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     quote_name_without_upper_casing,
+    unquote_if_quoted,
 )
 from snowflake.snowpark.exceptions import SnowparkSQLException
 from snowflake.snowpark.types import TimestampTimeZone, TimestampType
@@ -257,6 +258,7 @@ SESSION_CONFIG_KEY_WHITELIST = {
     "spark.sql.execution.pythonUDTF.arrow.enabled",
     "spark.sql.tvf.allowMultipleTableArguments.enabled",
     "snowpark.connect.sql.passthrough",
+    "snowpark.connect.cte.optimization_enabled",
     "snowpark.connect.iceberg.external_volume",
     "snowpark.connect.sql.identifiers.auto-uppercase",
     "snowpark.connect.udtf.compatibility_mode",
@@ -281,6 +283,7 @@ class SessionConfig:
     default_session_config = {
         "snowpark.connect.sql.identifiers.auto-uppercase": "all_except_columns",
         "snowpark.connect.sql.passthrough": "false",
+        "snowpark.connect.cte.optimization_enabled": "true",
         "snowpark.connect.udtf.compatibility_mode": "false",
         "snowpark.connect.views.duplicate_column_names_handling_mode": "rename",
         "spark.sql.execution.pythonUDTF.arrow.enabled": "false",
@@ -290,6 +293,7 @@ class SessionConfig:
 
     def __init__(self) -> None:
         self.config = deepcopy(self.default_session_config)
+        self.table_metadata: Dict[str, Dict[str, Any]] = {}
 
     def __getitem__(self, item: str) -> str:
         return self.get(item)
@@ -569,6 +573,12 @@ def set_snowflake_parameters(
                         snowpark_session.use_database(db)
                     case (prev, curr) if prev != curr:
                         snowpark_session.use_schema(prev)
+        case "snowpark.connect.cte.optimization_enabled":
+            # Set CTE optimization on the snowpark session
+            cte_enabled = str_to_bool(value)
+            snowpark_session.cte_optimization_enabled = cte_enabled
+            logger.info(f"Updated snowpark session CTE optimization: {cte_enabled}")
+
         case _:
             pass
 
@@ -578,6 +588,16 @@ def get_boolean_session_config_param(name: str) -> bool:
     return str_to_bool(session_config[name])
 
 
+def get_string_session_config_param(name: str) -> str:
+    session_config = sessions_config[get_session_id()]
+    return str(session_config[name])
+
+
+def get_cte_optimization_enabled() -> bool:
+    """Get the CTE optimization configuration setting."""
+    return get_boolean_session_config_param("snowpark.connect.cte.optimization_enabled")
+
+
 def auto_uppercase_column_identifiers() -> bool:
     session_config = sessions_config[get_session_id()]
     return session_config[
@@ -613,3 +633,81 @@ def get_timestamp_type():
             # shouldn't happen since `spark.sql.timestampType` is always defined, and `spark.conf.unset` sets it to default (TIMESTAMP_LTZ)
             timestamp_type = TimestampType(TimestampTimeZone.LTZ)
     return timestamp_type
+
+
+def record_table_metadata(
+    table_identifier: str,
+    table_type: str,
+    data_source: str,
+    supports_column_rename: bool = True,
+) -> None:
+    """
+    Record metadata about a table for Spark compatibility checks.
+
+    Args:
+        table_identifier: Full table identifier (catalog.database.table)
+        table_type: "v1" or "v2"
+        data_source: Source format (parquet, csv, iceberg, etc.)
+        supports_column_rename: Whether the table supports RENAME COLUMN
+    """
+    session_id = get_session_id()
+    session_config = sessions_config[session_id]
+
+    # Normalize table identifier for consistent lookup
+    # Use the full catalog.database.table identifier to avoid conflicts
+    normalized_identifier = table_identifier.upper().strip('"')
+
+    session_config.table_metadata[normalized_identifier] = {
+        "table_type": table_type,
+        "data_source": data_source,
+        "supports_column_rename": supports_column_rename,
+    }
+
+
+def get_table_metadata(table_identifier: str) -> Dict[str, Any] | None:
+    """
+    Get stored metadata for a table.
+
+    Args:
+        table_identifier: Full table identifier (catalog.database.table)
+
+    Returns:
+        Table metadata dict or None if not found
+    """
+    session_id = get_session_id()
+    session_config = sessions_config[session_id]
+
+    normalized_identifier = unquote_if_quoted(table_identifier).upper()
+
+    return session_config.table_metadata.get(normalized_identifier)
+
+
+def check_table_supports_operation(table_identifier: str, operation: str) -> bool:
+    """
+    Check if a table supports a given operation based on metadata and config.
+
+    Args:
+        table_identifier: Full table identifier (catalog.database.table)
+        operation: Operation to check (e.g., "rename_column")
+
+    Returns:
+        True if operation is supported, False if should be blocked
+    """
+    table_metadata = get_table_metadata(table_identifier)
+
+    if not table_metadata:
+        return True
+
+    session_id = get_session_id()
+    session_config = sessions_config[session_id]
+    enable_extensions = str_to_bool(
+        session_config.get("enable_snowflake_extension_behavior", "false")
+    )
+
+    if enable_extensions:
+        return True
+
+    if operation == "rename_column":
+        return table_metadata.get("supports_column_rename", True)
+
+    return True

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/dataframe_container.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Callable
 
 from snowflake import snowpark
 from snowflake.snowpark.types import StructField, StructType
-from snowflake.snowpark_connect.hidden_column import HiddenColumn
 
 if TYPE_CHECKING:
     from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
@@ -61,7 +60,6 @@ class DataFrameContainer:
         column_metadata: dict | None = None,
         column_qualifiers: list[list[str]] | None = None,
         parent_column_name_map: ColumnNameMap | None = None,
-        hidden_columns: set[HiddenColumn] | None = None,
         table_name: str | None = None,
         alias: str | None = None,
         cached_schema_getter: Callable[[], StructType] | None = None,
@@ -78,7 +76,6 @@ class DataFrameContainer:
             column_metadata: Optional metadata dictionary
             column_qualifiers: Optional column qualifiers
             parent_column_name_map: Optional parent column name map
-            hidden_columns: Optional list of hidden column names
             table_name: Optional table name
             alias: Optional alias
             cached_schema_getter: Optional function to get cached schema
@@ -101,7 +98,6 @@ class DataFrameContainer:
             column_metadata,
             column_qualifiers,
             parent_column_name_map,
-            hidden_columns,
         )
 
         # Determine the schema getter to use
@@ -226,7 +222,6 @@ class DataFrameContainer:
         column_metadata: dict | None = None,
         column_qualifiers: list[list[str]] | None = None,
         parent_column_name_map: ColumnNameMap | None = None,
-        hidden_columns: set[HiddenColumn] | None = None,
     ) -> ColumnNameMap:
         """Create a ColumnNameMap with the provided configuration."""
         from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
@@ -237,7 +232,6 @@ class DataFrameContainer:
             column_metadata=column_metadata,
             column_qualifiers=column_qualifiers,
             parent_column_name_map=parent_column_name_map,
-            hidden_columns=hidden_columns,
         )
 
     @staticmethod

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/expression/map_expression.py

@@ -38,6 +38,7 @@ from snowflake.snowpark_connect.utils.context import (
     get_current_lambda_params,
     is_function_argument_being_resolved,
     is_lambda_being_resolved,
+    not_resolving_fun_args,
 )
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
@@ -136,7 +137,10 @@ def map_expression(
         case "expression_string":
             return map_sql_expr(exp, column_mapping, typer)
         case "extension":
-            return map_extension.map_extension(exp, column_mapping, typer)
+            # Extensions can be passed as function args, and we need to reset the context here.
+            # Matters only for resolving alias expressions in the extensions rel.
+            with not_resolving_fun_args():
+                return map_extension.map_extension(exp, column_mapping, typer)
         case "lambda_function":
             lambda_name, lambda_body = map_single_column_expression(
                 exp.lambda_function.function, column_mapping, typer
@@ -278,13 +282,24 @@ def map_expression(
             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."
+                outer_col_name = (
+                    column_mapping.get_snowpark_column_name_from_spark_column_name(
+                        var_name, allow_non_exists=True
+                    )
                 )
+                if outer_col_name:
+                    col = snowpark_fn.col(outer_col_name)
+                    return ["namedlambdavariable()"], TypedColumn(
+                        col, lambda: typer.type(col)
+                    )
+                else:
+                    raise AnalysisException(
+                        f"Cannot resolve variable '{var_name}' within lambda function. "
+                        f"Lambda functions can access their own parameters and parent dataframe columns. "
+                        f"Current lambda parameters: {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])

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/expression/map_sql_expression.py

@@ -11,9 +11,10 @@ import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
 import pyspark.sql.connect.proto.types_pb2 as types_proto
 from google.protobuf.any_pb2 import Any
 from pyspark.errors.exceptions.base import AnalysisException
+from pyspark.sql.connect import functions as pyspark_functions
 
 import snowflake.snowpark_connect.proto.snowflake_expression_ext_pb2 as snowflake_proto
-from snowflake import snowpark
+from snowflake.snowpark._internal.analyzer.analyzer_utils import unquote_if_quoted
 from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.typed_column import TypedColumn
@@ -89,6 +90,11 @@ def as_scala_seq(input):
     )
 
 
+@cache
+def _scala_some():
+    return jpype.JClass("scala.Some")
+
+
 def map_sql_expr(
     exp: expressions_proto.Expression,
     column_mapping: ColumnNameMap,
@@ -223,9 +229,6 @@ def apply_filter_clause(
 
 
 def map_logical_plan_expression(exp: jpype.JObject) -> expressions_proto.Expression:
-    from snowflake.snowpark_connect.expression.map_expression import (
-        map_single_column_expression,
-    )
     from snowflake.snowpark_connect.relation.map_sql import map_logical_plan_relation
 
     class_name = str(exp.getClass().getSimpleName())
@@ -308,22 +311,23 @@ def map_logical_plan_expression(exp: jpype.JObject) -> expressions_proto.Express
             )
             proto = expressions_proto.Expression(extension=any_proto)
         case "ExpressionWithUnresolvedIdentifier":
-            plan_id = None
-            identifierExpr = map_logical_plan_expression(exp.identifierExpr())
-            session = snowpark.Session.get_active_session()
-            m = ColumnNameMap([], [], None)
-            expr = map_single_column_expression(
-                identifierExpr, m, ExpressionTyper.dummy_typer(session)
+            from snowflake.snowpark_connect.relation.map_sql import (
+                get_relation_identifier_name,
             )
-            value = session.range(1).select(expr[1].col).collect()[0][0]
 
-            proto = expressions_proto.Expression(
-                unresolved_attribute=expressions_proto.Expression.UnresolvedAttribute(
-                    unparsed_identifier=str(value),
-                    plan_id=plan_id,
-                ),
-            )
-            # TODO: support identifier referencing unresolved function
+            value = unquote_if_quoted(get_relation_identifier_name(exp))
+            if getattr(pyspark_functions, value.lower(), None) is not None:
+                unresolved_function = exp.exprBuilder().apply(
+                    _scala_some()(value).toList()
+                )
+                proto = map_logical_plan_expression(unresolved_function)
+            else:
+                proto = expressions_proto.Expression(
+                    unresolved_attribute=expressions_proto.Expression.UnresolvedAttribute(
+                        unparsed_identifier=str(value),
+                        plan_id=None,
+                    ),
+                )
         case "InSubquery":
             rel_proto = map_logical_plan_relation(exp.query().plan())
             any_proto = Any()

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/expression/map_unresolved_attribute.py

@@ -163,7 +163,6 @@ def map_unresolved_attribute(
     attr_name = ".".join(name_parts)
 
     has_plan_id = exp.unresolved_attribute.HasField("plan_id")
-    source_qualifiers = None
 
     if has_plan_id:
         plan_id = exp.unresolved_attribute.plan_id
@@ -172,27 +171,13 @@ def map_unresolved_attribute(
         assert (
             target_df is not None
         ), f"resolving an attribute of a unresolved dataframe {plan_id}"
-
-        # Get the qualifiers for this column from the target DataFrame
-        source_qualifiers = (
-            target_df_container.column_map.get_qualifier_for_spark_column(
-                name_parts[-1]
-            )
-        )
-
-        if hasattr(column_mapping, "hidden_columns"):
-            hidden = column_mapping.hidden_columns
-        else:
-            hidden = None
-
         column_mapping = target_df_container.column_map
-        column_mapping.hidden_columns = hidden
         typer = ExpressionTyper(target_df)
 
-    def get_col(snowpark_name, has_hidden=False):
+    def get_col(snowpark_name):
         return (
             snowpark_fn.col(snowpark_name)
-            if not has_plan_id or has_hidden
+            if not has_plan_id
             else target_df.col(snowpark_name)
         )
 
@@ -277,17 +262,10 @@ def map_unresolved_attribute(
         quoted_attr_name = name_parts[0]
 
     snowpark_name = column_mapping.get_snowpark_column_name_from_spark_column_name(
-        quoted_attr_name,
-        allow_non_exists=True,
-        is_qualified=has_plan_id,
-        source_qualifiers=source_qualifiers if has_plan_id else None,
+        quoted_attr_name, allow_non_exists=True
     )
-
     if snowpark_name is not None:
-        is_hidden = column_mapping.is_hidden_column_reference(
-            quoted_attr_name, source_qualifiers
-        )
-        col = get_col(snowpark_name, is_hidden)
+        col = get_col(snowpark_name)
         qualifiers = column_mapping.get_qualifier_for_spark_column(quoted_attr_name)
     else:
         # this means it has to be a struct column with a field name

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -2619,9 +2619,18 @@ def map_unresolved_function(
                     result_type = input_type.element_type
                     result_exp = fn(snowpark_args[0])
                 case _:
-                    spark_col_names = ["key", "value"]
-                    result_exp = fn(snowpark_args[0])
-                    result_type = [input_type.key_type, input_type.value_type]
+                    # Check if the type has map-like attributes before accessing them
+                    if hasattr(input_type, "key_type") and hasattr(
+                        input_type, "value_type"
+                    ):
+                        spark_col_names = ["key", "value"]
+                        result_exp = fn(snowpark_args[0])
+                        result_type = [input_type.key_type, input_type.value_type]
+                    else:
+                        # Throw proper error for types without key_type/value_type attributes
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the ("ARRAY" or "MAP") type, however "{snowpark_arg_names[0]}" has the type "{str(input_type)}".'
+                        )
         case "expm1":
             spark_function_name = f"EXPM1({snowpark_arg_names[0]})"
             result_exp = snowpark_fn.exp(*snowpark_args) - 1

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/expression/map_unresolved_star.py

@@ -34,7 +34,6 @@ def map_unresolved_star(
     column_mapping: ColumnNameMap,
     typer: ExpressionTyper,
 ) -> tuple[list[str], TypedColumn]:
-
     if exp.unresolved_star.HasField("unparsed_target"):
         unparsed_target = exp.unresolved_star.unparsed_target
         name_parts = split_fully_qualified_spark_name(unparsed_target)
@@ -103,7 +102,7 @@ def map_unresolved_star(
                 prefix_candidate_str = f"{prefix_candidate_str}.{name_parts[i]}"
             prefix_candidate = (
                 column_mapping.get_snowpark_column_name_from_spark_column_name(
-                    prefix_candidate_str, allow_non_exists=True, is_qualified=(i > 0)
+                    prefix_candidate_str, allow_non_exists=True
                 )
             )
             if prefix_candidate is None:
@@ -181,7 +180,7 @@ def map_unresolved_star_struct(
             prefix_candidate_str = f"{prefix_candidate_str}.{name_parts[i]}"
         prefix_candidate = (
             column_mapping.get_snowpark_column_name_from_spark_column_name(
-                prefix_candidate_str, allow_non_exists=True, is_qualified=(i > 0)
+                prefix_candidate_str, allow_non_exists=True
             )
         )
         if prefix_candidate is None:

{snowpark_connect-0.27.0 → snowpark_connect-0.28.0}/src/snowflake/snowpark_connect/relation/map_extension.py

@@ -23,7 +23,6 @@ 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,
 )
@@ -336,15 +335,14 @@ def map_aggregate(
     typer = ExpressionTyper(input_df)
 
     def _map_column(exp: expression_proto.Expression) -> tuple[str, TypedColumn]:
-        with not_resolving_fun_args():
-            new_names, snowpark_column = map_expression(
-                exp, input_container.column_map, typer
+        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"
             )
-            if len(new_names) != 1:
-                raise SnowparkConnectNotImplementedError(
-                    "Multi-column aggregate expressions are not supported"
-                )
-            return new_names[0], snowpark_column
+        return new_names[0], snowpark_column
 
     raw_groupings: list[tuple[str, TypedColumn]] = []
     raw_aggregations: list[tuple[str, TypedColumn]] = []
@@ -431,12 +429,18 @@ def map_aggregate(
             if groupings:
                 # Normal GROUP BY with explicit grouping columns
                 result = input_df.group_by(groupings)
-            else:
+            elif not is_group_by_all:
                 # No explicit GROUP BY - this is an aggregate over the entire table
                 # Use a dummy constant that will be excluded from the final result
                 result = input_df.with_column(
                     "__dummy_group__", snowpark_fn.lit(1)
                 ).group_by("__dummy_group__")
+            else:
+                # GROUP BY ALL with only one aggregate column
+                # Snowpark doesn't support GROUP BY ALL
+                # TODO: Change in future with Snowpark Supported arguments or API for GROUP BY ALL
+                result = input_df.group_by()
+
         case snowflake_proto.Aggregate.GROUP_TYPE_ROLLUP:
             result = input_df.rollup(groupings)
         case snowflake_proto.Aggregate.GROUP_TYPE_CUBE: