snowpark-connect 0.20.2__py3-none-any.whl → 0.21.0__py3-none-any.whl

snowflake/snowpark_connect/analyze_plan/map_tree_string.py

@@ -15,8 +15,9 @@ def map_tree_string(
 ) -> proto_base.AnalyzePlanResponse:
     # TODO: tracking the difference with pyspark in SNOW-1853347
     tree_string = request.tree_string
-    snowpark_df = map_relation(tree_string.plan.root)
-    column_map = snowpark_df._column_map
+    snowpark_df_container = map_relation(tree_string.plan.root)
+    snowpark_df = snowpark_df_container.dataframe
+    column_map = snowpark_df_container.column_map
 
     snowpark_tree_string = snowpark_df._format_schema(
         level=tree_string.level if tree_string.HasField("level") else None,

snowflake/snowpark_connect/column_name_handler.py

@@ -12,14 +12,13 @@ from functools import cached_property
 
 from pyspark.errors.exceptions.base import AnalysisException
 
-from snowflake import snowpark
 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.utils import quote_name
-from snowflake.snowpark.types import DataType, StructField, StructType
+from snowflake.snowpark.types import StructType
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.utils.context import get_current_operation_scope
 
@@ -41,64 +40,6 @@ def set_schema_getter(df: DataFrame, get_schema: Callable[[], StructType]) -> No
     df.__class__ = PatchedDataFrame
 
 
-def with_column_map(
-    result_df: snowpark.DataFrame,
-    spark_column_names: list[str],
-    snowpark_column_names: list[str],
-    snowpark_column_types: list[DataType] = None,
-    column_metadata: dict | None = None,
-    column_qualifiers: list[list[str]] | None = None,
-    parent_column_name_map: ColumnNameMap | None = None,
-) -> snowpark.DataFrame:
-    """
-    Build a mapping from the DataFrame's column names to the Spark column names.
-
-    This is used to track the original column names and handle column naming differences
-    between Spark and Snowpark.
-
-    The elements in result_df.columns and the elements in spark_column_names must be a one-to-one mapping.
-
-    Args:
-        result_df (snowpark.DataFrame): The DataFrame to map.
-        spark_column_names (list[str]): The Spark column names.
-        snowpark_column_names (list[str]): The Snowpark column names.
-        snowpark_column_types (list[DataType], optional): The Snowpark column types. **if provided df.schema will be overridden with inferred schema**
-        column_metadata (dict, optional): Metadata for the columns.
-        column_qualifiers (list[list[str]], optional): Qualifiers for the columns, used to handle table aliases or DataFrame aliases.
-        parent_column_name_map (ColumnNameMap, optional): A ColumnNameMap, that came from the dataframe used to create result_df (parent df)
-
-    Returns:
-        snowpark.DataFrame: The mapped DataFrame.
-    """
-    assert len(snowpark_column_names) == len(
-        spark_column_names
-    ), "Number of Spark column names must match number of columns in DataFrame"
-    result_df._column_map = ColumnNameMap(
-        spark_column_names,
-        snowpark_column_names,
-        column_metadata=column_metadata,
-        column_qualifiers=column_qualifiers,
-        parent_column_name_map=parent_column_name_map,
-    )
-    result_df._table_name = None
-
-    if snowpark_column_types is not None:
-        assert len(snowpark_column_names) == len(
-            snowpark_column_types
-        ), "Number of Snowpark column names and types must match"
-
-        set_schema_getter(
-            result_df,
-            lambda: StructType(
-                [
-                    StructField(n, t, _is_column=False)
-                    for n, t in zip(snowpark_column_names, snowpark_column_types)
-                ]
-            ),
-        )
-    return result_df
-
-
 def make_column_names_snowpark_compatible(
     names: list[str], plan_id: int, offset: int = 0
 ) -> list[str]:
@@ -189,7 +130,7 @@ class ColumnNameMap:
         column_qualifiers: Optional qualifiers for the columns, used to handle table aliases or DataFrame aliases.
         parent_column_name_map: parent ColumnNameMap
         """
-        self.columns = []
+        self.columns: list[ColumnNames] = []
         self.spark_to_col = defaultdict(list)
         self.uppercase_spark_to_col = defaultdict(list)
         self.snowpark_to_col = defaultdict(list)
@@ -602,11 +543,11 @@ class ColumnNameMap:
 class JoinColumnNameMap(ColumnNameMap):
     def __init__(
         self,
-        left_input: snowpark.DataFrame,
-        right_input: snowpark.DataFrame,
+        left_colmap: ColumnNameMap,
+        right_colmap: ColumnNameMap,
     ) -> None:
-        self.left_column_mapping: ColumnNameMap = left_input._column_map
-        self.right_column_mapping: ColumnNameMap = right_input._column_map
+        self.left_column_mapping: ColumnNameMap = left_colmap
+        self.right_column_mapping: ColumnNameMap = right_colmap
 
     def get_snowpark_column_name_from_spark_column_name(
         self,

snowflake/snowpark_connect/config.py

@@ -9,7 +9,7 @@ import re
 import sys
 import time
 from collections import defaultdict
-from copy import copy
+from copy import copy, deepcopy
 from typing import Any
 
 import jpype
@@ -33,7 +33,7 @@ from snowflake.snowpark_connect.version import VERSION as sas_version
 
 
 def str_to_bool(boolean_str: str) -> bool:
-    assert boolean_str in [
+    assert boolean_str in (
         "True",
         "true",
         "False",
@@ -41,7 +41,7 @@ def str_to_bool(boolean_str: str) -> bool:
         "1",
         "0",
         "",  # This is the default value, equivalent to False.
-    ], f"Invalid boolean value: {boolean_str}"
+    ), f"Invalid boolean value: {boolean_str}"
     return boolean_str in ["True", "true", "1"]
 
 
@@ -131,6 +131,7 @@ class GlobalConfig:
         "spark.sql.caseSensitive": "false",
         "spark.sql.mapKeyDedupPolicy": "EXCEPTION",
         "spark.sql.ansi.enabled": "false",
+        "spark.sql.legacy.allowHashOnMapType": "false",
         "spark.sql.sources.default": "parquet",
         "spark.Catalog.databaseFilterInformationSchema": "false",
         "spark.sql.parser.quotedRegexColumnNames": "false",
@@ -145,6 +146,7 @@ class GlobalConfig:
         "spark.sql.crossJoin.enabled",
         "spark.sql.caseSensitive",
         "spark.sql.ansi.enabled",
+        "spark.sql.legacy.allowHashOnMapType",
         "spark.Catalog.databaseFilterInformationSchema",
         "spark.sql.parser.quotedRegexColumnNames",
     ]
@@ -250,10 +252,10 @@ SESSION_CONFIG_KEY_WHITELIST = {
     "spark.sql.tvf.allowMultipleTableArguments.enabled",
     "snowpark.connect.sql.passthrough",
     "snowpark.connect.iceberg.external_volume",
-    "snowpark.connect.auto-uppercase.ddl",
-    "snowpark.connect.auto-uppercase.dml",
+    "snowpark.connect.sql.identifiers.auto-uppercase",
     "snowpark.connect.udtf.compatibility_mode",
     "snowpark.connect.views.duplicate_column_names_handling_mode",
+    "enable_snowflake_extension_behavior",
 }
 AZURE_SAS_KEY = re.compile(
     r"^fs\.azure\.sas\.[^\.]+\.[^\.]+\.blob\.core\.windows\.net$"
@@ -271,17 +273,17 @@ class SessionConfig:
     """This class contains the session configuration for the Spark Server."""
 
     default_session_config = {
-        "snowpark.connect.auto-uppercase.ddl": "true",
-        "snowpark.connect.auto-uppercase.dml": "true",
+        "snowpark.connect.sql.identifiers.auto-uppercase": "all_except_columns",
         "snowpark.connect.sql.passthrough": "false",
         "snowpark.connect.udtf.compatibility_mode": "false",
         "snowpark.connect.views.duplicate_column_names_handling_mode": "rename",
         "spark.sql.execution.pythonUDTF.arrow.enabled": "false",
         "spark.sql.tvf.allowMultipleTableArguments.enabled": "true",
+        "enable_snowflake_extension_behavior": "false",
     }
 
     def __init__(self) -> None:
-        self.config = copy(self.default_session_config)
+        self.config = deepcopy(self.default_session_config)
 
     def __getitem__(self, item: str) -> str:
         return self.get(item)
@@ -304,7 +306,13 @@ CONFIG_ALLOWED_VALUES: dict[str, tuple] = {
         "rename",
         "fail",
         "drop",
-    )
+    ),
+    "snowpark.connect.sql.identifiers.auto-uppercase": (
+        "all_except_columns",
+        "only_columns",
+        "all",
+        "none",
+    ),
 }
 
 # Set some default configuration that are necessary for the driver.
@@ -533,7 +541,7 @@ def set_snowflake_parameters(
                 value = global_config.default_static_global_config.get(key)
 
             snowpark_name = quote_name_without_upper_casing(value)
-            if auto_uppercase_ddl():
+            if auto_uppercase_non_column_identifiers():
                 snowpark_name = snowpark_name.upper()
 
             # Create the schema on demand. Before creating it, however,
@@ -568,9 +576,15 @@ def get_boolean_session_config_param(name: str) -> bool:
     return str_to_bool(session_config[name])
 
 
-def auto_uppercase_dml() -> bool:
-    return get_boolean_session_config_param("snowpark.connect.auto-uppercase.dml")
+def auto_uppercase_column_identifiers() -> bool:
+    session_config = sessions_config[get_session_id()]
+    return session_config[
+        "snowpark.connect.sql.identifiers.auto-uppercase"
+    ].lower() in ("all", "only_columns")
 
 
-def auto_uppercase_ddl() -> bool:
-    return get_boolean_session_config_param("snowpark.connect.auto-uppercase.ddl")
+def auto_uppercase_non_column_identifiers() -> bool:
+    session_config = sessions_config[get_session_id()]
+    return session_config[
+        "snowpark.connect.sql.identifiers.auto-uppercase"
+    ].lower() in ("all", "all_except_columns")

snowflake/snowpark_connect/dataframe_container.py

@@ -0,0 +1,242 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from snowflake import snowpark
+from snowflake.snowpark.types import StructField, StructType
+
+if TYPE_CHECKING:
+    from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+
+
+class DataFrameContainer:
+    """
+    A container class that wraps a Snowpark DataFrame along with additional metadata.
+
+    This class provides a unified interface for managing Snowpark DataFrames along with
+    their column mappings, schema information, and metadata.
+    """
+
+    def __init__(
+        self,
+        dataframe: snowpark.DataFrame,
+        column_map: ColumnNameMap | None = None,
+        table_name: str | None = None,
+        alias: str | None = None,
+        cached_schema_getter: Callable[[], StructType] | None = None,
+    ) -> None:
+        """
+        Initialize a new DataFrameContainer.
+
+        Args:
+            dataframe: The underlying Snowpark DataFrame
+            column_map: Optional column name mapping
+            table_name: Optional table name for the DataFrame
+            alias: Optional alias for the DataFrame
+            cached_schema_getter: Optional function to get cached schema
+        """
+        self._dataframe = dataframe
+        self._column_map = self._create_default_column_map(column_map)
+        self._table_name = table_name
+        self._alias = alias
+
+        if cached_schema_getter is not None:
+            self._apply_cached_schema_getter(cached_schema_getter)
+
+    @classmethod
+    def create_with_column_mapping(
+        cls,
+        dataframe: snowpark.DataFrame,
+        spark_column_names: list[str],
+        snowpark_column_names: list[str],
+        snowpark_column_types: list | None = None,
+        column_metadata: dict | None = None,
+        column_qualifiers: list[list[str]] | None = None,
+        parent_column_name_map: ColumnNameMap | None = None,
+        table_name: str | None = None,
+        alias: str | None = None,
+        cached_schema_getter: Callable[[], StructType] | None = None,
+    ) -> DataFrameContainer:
+        """
+        Create a new container with complete column mapping configuration.
+
+        Args:
+            dataframe: The underlying Snowpark DataFrame
+            spark_column_names: List of Spark column names
+            snowpark_column_names: List of corresponding Snowpark column names
+            snowpark_column_types: Optional list of column types
+            column_metadata: Optional metadata dictionary
+            column_qualifiers: Optional column qualifiers
+            parent_column_name_map: Optional parent column name map
+            table_name: Optional table name
+            alias: Optional alias
+            cached_schema_getter: Optional function to get cached schema
+
+        Returns:
+            A new DataFrameContainer instance
+
+        Raises:
+            AssertionError: If column names and types don't match expected lengths
+        """
+        # Validate inputs
+        cls._validate_column_mapping_inputs(
+            spark_column_names, snowpark_column_names, snowpark_column_types
+        )
+
+        column_map = cls._create_column_map(
+            spark_column_names,
+            snowpark_column_names,
+            column_metadata,
+            column_qualifiers,
+            parent_column_name_map,
+        )
+
+        # Determine the schema getter to use
+        final_schema_getter = None
+
+        if cached_schema_getter is not None:
+            # Use the provided schema getter
+            final_schema_getter = cached_schema_getter
+        elif snowpark_column_types is not None:
+            # Create schema from types and wrap in function
+            schema = cls._create_schema_from_types(
+                snowpark_column_names, snowpark_column_types
+            )
+            if schema is not None:
+
+                def get_schema():
+                    return schema
+
+                final_schema_getter = get_schema
+
+        return cls(
+            dataframe=dataframe,
+            column_map=column_map,
+            table_name=table_name,
+            alias=alias,
+            cached_schema_getter=final_schema_getter,
+        )
+
+    @property
+    def dataframe(self) -> snowpark.DataFrame:
+        """Get the underlying Snowpark DataFrame."""
+        # Ensure the DataFrame has the _column_map attribute for backward compatibility
+        # Some of the snowpark code needs references to _column_map
+        self._dataframe._column_map = self._column_map
+        return self._dataframe
+
+    @property
+    def column_map(self) -> ColumnNameMap:
+        """Get the column name mapping."""
+        return self._column_map
+
+    @column_map.setter
+    def column_map(self, value: ColumnNameMap) -> None:
+        """Set the column name mapping."""
+        self._column_map = value
+
+    @property
+    def table_name(self) -> str | None:
+        """Get the table name."""
+        return self._table_name
+
+    @table_name.setter
+    def table_name(self, value: str | None) -> None:
+        """Set the table name."""
+        self._table_name = value
+
+    @property
+    def alias(self) -> str | None:
+        """Get the alias name."""
+        return self._alias
+
+    @alias.setter
+    def alias(self, value: str | None) -> None:
+        """Set the alias name."""
+        self._alias = value
+
+    def _create_default_column_map(
+        self, column_map: ColumnNameMap | None
+    ) -> ColumnNameMap:
+        """Create a default column map if none provided."""
+        if column_map is not None:
+            return column_map
+
+        from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+
+        return ColumnNameMap([], [])
+
+    def _apply_cached_schema_getter(
+        self, schema_getter: Callable[[], StructType]
+    ) -> None:
+        """Apply a cached schema getter to the dataframe."""
+        from snowflake.snowpark_connect.column_name_handler import set_schema_getter
+
+        set_schema_getter(self._dataframe, schema_getter)
+
+    @staticmethod
+    def _validate_column_mapping_inputs(
+        spark_column_names: list[str],
+        snowpark_column_names: list[str],
+        snowpark_column_types: list | None = None,
+    ) -> None:
+        """
+        Validate inputs for column mapping creation.
+
+        Raises:
+            AssertionError: If validation fails
+        """
+        assert len(snowpark_column_names) == len(
+            spark_column_names
+        ), "Number of Spark column names must match number of columns in DataFrame"
+
+        if snowpark_column_types is not None:
+            assert len(snowpark_column_names) == len(
+                snowpark_column_types
+            ), "Number of Snowpark column names and types must match"
+
+    @staticmethod
+    def _create_column_map(
+        spark_column_names: list[str],
+        snowpark_column_names: list[str],
+        column_metadata: dict | None = None,
+        column_qualifiers: list[list[str]] | None = None,
+        parent_column_name_map: ColumnNameMap | None = None,
+    ) -> ColumnNameMap:
+        """Create a ColumnNameMap with the provided configuration."""
+        from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+
+        return ColumnNameMap(
+            spark_column_names,
+            snowpark_column_names,
+            column_metadata=column_metadata,
+            column_qualifiers=column_qualifiers,
+            parent_column_name_map=parent_column_name_map,
+        )
+
+    @staticmethod
+    def _create_schema_from_types(
+        snowpark_column_names: list[str],
+        snowpark_column_types: list | None,
+    ) -> StructType | None:
+        """
+        Create a StructType schema from column names and types.
+
+        Returns:
+            StructType if types are provided, None otherwise
+        """
+        if snowpark_column_types is None:
+            return None
+
+        return StructType(
+            [
+                StructField(name, column_type, _is_column=False)
+                for name, column_type in zip(
+                    snowpark_column_names, snowpark_column_types
+                )
+            ]
+        )

snowflake/snowpark_connect/execute_plan/map_execution_command.py

@@ -1,21 +1,13 @@
 #
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
-
 from collections import Counter
 
 import pyspark.sql.connect.proto.base_pb2 as proto_base
 import pyspark.sql.connect.proto.relations_pb2 as relation_proto
 
-from snowflake.snowpark._internal.analyzer.analyzer_utils import (
-    quote_name_without_upper_casing,
-)
 from snowflake.snowpark_connect.column_name_handler import ColumnNames
-from snowflake.snowpark_connect.config import (
-    auto_uppercase_ddl,
-    global_config,
-    sessions_config,
-)
+from snowflake.snowpark_connect.config import global_config, sessions_config
 from snowflake.snowpark_connect.constants import SERVER_SIDE_SESSION_ID
 from snowflake.snowpark_connect.execute_plan.utils import pandas_to_arrow_batches_bytes
 from snowflake.snowpark_connect.expression import map_udf
@@ -24,24 +16,23 @@ from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.relation.map_sql import map_sql_to_pandas_df
 from snowflake.snowpark_connect.relation.write.map_write import map_write, map_write_v2
 from snowflake.snowpark_connect.utils.context import get_session_id
+from snowflake.snowpark_connect.utils.identifiers import (
+    spark_to_sf_single_id,
+    spark_to_sf_single_id_with_unquoting,
+)
 from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
 
 
-def _spark_to_snowflake_single_id(name: str) -> str:
-    name = quote_name_without_upper_casing(name)
-    return name.upper() if auto_uppercase_ddl() else name
-
-
 def _create_column_rename_map(
     columns: list[ColumnNames], rename_duplicated: bool
 ) -> dict:
     if rename_duplicated is False:
         # if we are not renaming duplicated columns, we can just return the original names
         return {
-            col.snowpark_name: _spark_to_snowflake_single_id(col.spark_name)
+            col.snowpark_name: spark_to_sf_single_id(col.spark_name, is_column=True)
             for col in columns
         }
 
@@ -64,7 +55,7 @@ def _create_column_rename_map(
 
     if len(renamed_cols) == 0:
         return {
-            col.snowpark_name: _spark_to_snowflake_single_id(col.spark_name)
+            col.snowpark_name: spark_to_sf_single_id(col.spark_name, is_column=True)
             for col in not_renamed_cols
         }
 
@@ -95,12 +86,9 @@ def map_execution_command(
     match request.plan.command.WhichOneof("command_type"):
         case "create_dataframe_view":
             req = request.plan.command.create_dataframe_view
-            input_df = map_relation(req.input)
-            # Use real column names when writing to sf.
-            assert hasattr(
-                input_df, "_column_map"
-            ), "input_df does not have the _column_map attribute"
-            column_map = input_df._column_map
+            input_df_container = map_relation(req.input)
+            input_df = input_df_container.dataframe
+            column_map = input_df_container.column_map
 
             session_config = sessions_config[get_session_id()]
             duplicate_column_names_handling_mode = session_config[
@@ -133,7 +121,9 @@ def map_execution_command(
                 view_name = [global_config.spark_sql_globalTempDatabase, req.name]
             else:
                 view_name = [req.name]
-            view_name = [_spark_to_snowflake_single_id(part) for part in view_name]
+            view_name = [
+                spark_to_sf_single_id_with_unquoting(part) for part in view_name
+            ]
 
             if req.replace:
                 input_df.create_or_replace_temp_view(view_name)

snowflake/snowpark_connect/execute_plan/map_execution_root.py

@@ -20,6 +20,7 @@ from snowflake.snowpark._internal.utils import (
     create_or_update_statement_params_with_query_tag,
 )
 from snowflake.snowpark_connect.constants import SERVER_SIDE_SESSION_ID
+from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.execute_plan.utils import (
     arrow_table_to_arrow_bytes,
     pandas_to_arrow_batches_bytes,
@@ -89,13 +90,16 @@ def to_arrow_batch_iter(result_df: snowpark.DataFrame) -> Iterator[Table]:
 def map_execution_root(
     request: proto_base.ExecutePlanRequest,
 ) -> Iterator[proto_base.ExecutePlanResponse | QueryResult]:
-    result_df: snowpark.DataFrame | pandas.DataFrame = map_relation(request.plan.root)
+    result: DataFrameContainer | pandas.DataFrame = map_relation(request.plan.root)
+    if isinstance(result, pandas.DataFrame):
+        result_df = result
+    else:
+        result_df = result.dataframe
+
     if isinstance(result_df, snowpark.DataFrame):
         snowpark_schema = result_df.schema
-        schema = snowpark_to_proto_type(
-            snowpark_schema, result_df._column_map, result_df
-        )
-        spark_columns = result_df._column_map.get_spark_columns()
+        schema = snowpark_to_proto_type(snowpark_schema, result.column_map, result_df)
+        spark_columns = result.column_map.get_spark_columns()
         if tcm.TCM_MODE:
             # TCM result handling:
             # - small result (only one batch): just return the executePlanResponse

snowflake/snowpark_connect/expression/map_extension.py

@@ -58,7 +58,8 @@ def map_extension(
             from snowflake.snowpark_connect.relation.map_relation import map_relation
 
             with push_evaluating_sql_scope():
-                df = map_relation(extension.subquery_expression.input)
+                df_container = map_relation(extension.subquery_expression.input)
+                df = df_container.dataframe
 
             queries = df.queries["queries"]
             if len(queries) != 1:

snowflake/snowpark_connect/expression/map_unresolved_attribute.py

@@ -17,15 +17,15 @@ from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.expression.typer import ExpressionTyper
 from snowflake.snowpark_connect.typed_column import TypedColumn
-from snowflake.snowpark_connect.utils.attribute_handling import (
-    split_fully_qualified_spark_name,
-)
 from snowflake.snowpark_connect.utils.context import (
     get_is_evaluating_sql,
     get_outer_dataframes,
     get_plan_id_map,
     resolve_lca_alias,
 )
+from snowflake.snowpark_connect.utils.identifiers import (
+    split_fully_qualified_spark_name,
+)
 
 SPARK_QUOTED = re.compile("^(`.*`)$", re.DOTALL)
 
@@ -46,11 +46,12 @@ def map_unresolved_attribute(
 
     if has_plan_id:
         plan_id = exp.unresolved_attribute.plan_id
-        target_df = get_plan_id_map(plan_id)
+        target_df_container = get_plan_id_map(plan_id)
+        target_df = target_df_container.dataframe
         assert (
             target_df is not None
         ), f"resolving an attribute of a unresolved dataframe {plan_id}"
-        column_mapping = target_df._column_map
+        column_mapping = target_df_container.column_map
         typer = ExpressionTyper(target_df)
 
     def get_col(snowpark_name):
@@ -146,8 +147,8 @@ def map_unresolved_attribute(
             name_parts[0], allow_non_exists=True
         )
         if snowpark_name is None:
-            for outer_df in get_outer_dataframes():
-                snowpark_name = outer_df._column_map.get_snowpark_column_name_from_spark_column_name(
+            for outer_df_container in get_outer_dataframes():
+                snowpark_name = outer_df_container.column_map.get_snowpark_column_name_from_spark_column_name(
                     name_parts[0], allow_non_exists=True
                 )
                 if snowpark_name is not None: