snowpark-connect 0.28.0__py3-none-any.whl → 0.28.1__py3-none-any.whl

snowflake/snowpark_connect/config.py

@@ -283,7 +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.cte.optimization_enabled": "false",
         "snowpark.connect.udtf.compatibility_mode": "false",
         "snowpark.connect.views.duplicate_column_names_handling_mode": "rename",
         "spark.sql.execution.pythonUDTF.arrow.enabled": "false",

snowflake/snowpark_connect/execute_plan/map_execution_command.py

@@ -1,18 +1,16 @@
 #
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
-import re
-import uuid
 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 import DataFrame, Session
-from snowflake.snowpark.exceptions import SnowparkSQLException
+from snowflake.snowpark.types import StructField, StructType
 from snowflake.snowpark_connect.column_name_handler import ColumnNames
 from snowflake.snowpark_connect.config import global_config, sessions_config
 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 pandas_to_arrow_batches_bytes
 from snowflake.snowpark_connect.expression import map_udf
 from snowflake.snowpark_connect.relation import map_udtf
@@ -28,10 +26,7 @@ from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
-
-_INTERNAL_VIEW_PREFIX = "__SC_RENAMED_V_"
-
-_CREATE_VIEW_PATTERN = re.compile(r"create\s+or\s+replace\s+view", re.IGNORECASE)
+from snowflake.snowpark_connect.utils.temporary_view_cache import register_temp_view
 
 
 def _create_column_rename_map(
@@ -98,32 +93,35 @@ def map_execution_command(
             input_df = input_df_container.dataframe
             column_map = input_df_container.column_map
 
+            # TODO: Remove code handling deduplication. When view are not materialized we don't have to care about it.
             session_config = sessions_config[get_session_id()]
             duplicate_column_names_handling_mode = session_config[
                 "snowpark.connect.views.duplicate_column_names_handling_mode"
             ]
 
+            spark_columns = input_df_container.column_map.get_spark_columns()
             # rename columns to match spark names
             if duplicate_column_names_handling_mode == "rename":
                 # deduplicate column names by appending _DEDUP_1, _DEDUP_2, etc.
-                input_df = input_df.rename(
-                    _create_column_rename_map(column_map.columns, True)
-                )
+                rename_map = _create_column_rename_map(column_map.columns, True)
+                snowpark_columns = list(rename_map.values())
+                input_df = input_df.rename(rename_map)
             elif duplicate_column_names_handling_mode == "drop":
                 # Drop duplicate column names by removing all but the first occurrence.
                 duplicated_columns, remaining_columns = _find_duplicated_columns(
                     column_map.columns
                 )
+                rename_map = _create_column_rename_map(remaining_columns, False)
+                snowpark_columns = list(rename_map.values())
+                spark_columns = list(dict.fromkeys(spark_columns))
                 if len(duplicated_columns) > 0:
                     input_df = input_df.drop(*duplicated_columns)
-                input_df = input_df.rename(
-                    _create_column_rename_map(remaining_columns, False)
-                )
+                input_df = input_df.rename(rename_map)
             else:
                 # rename columns without deduplication
-                input_df = input_df.rename(
-                    _create_column_rename_map(column_map.columns, False)
-                )
+                rename_map = _create_column_rename_map(column_map.columns, True)
+                snowpark_columns = list(rename_map.values())
+                input_df = input_df.rename(rename_map)
 
             if req.is_global:
                 view_name = [global_config.spark_sql_globalTempDatabase, req.name]
@@ -132,18 +130,23 @@ def map_execution_command(
             view_name = [
                 spark_to_sf_single_id_with_unquoting(part) for part in view_name
             ]
+            joined_view_name = ".".join(view_name)
 
-            if req.replace:
-                try:
-                    input_df.create_or_replace_temp_view(view_name)
-                except SnowparkSQLException as exc:
-                    if _is_error_caused_by_view_referencing_itself(exc):
-                        # This error is caused by statement with self reference like `CREATE VIEW A AS SELECT X FROM A`.
-                        _create_chained_view(input_df, view_name)
-                    else:
-                        raise
-            else:
-                input_df.create_temp_view(view_name)
+            schema = StructType(
+                [
+                    StructField(field.name, field.datatype)
+                    for field in input_df.schema.fields
+                ]
+            )
+            input_df_container = DataFrameContainer.create_with_column_mapping(
+                dataframe=input_df,
+                spark_column_names=spark_columns,
+                snowpark_column_names=snowpark_columns,
+                parent_column_name_map=input_df_container.column_map,
+                cached_schema_getter=lambda: schema,
+            )
+
+            register_temp_view(joined_view_name, input_df_container, req.replace)
         case "write_stream_operation_start":
             match request.plan.command.write_stream_operation_start.format:
                 case "console":
@@ -207,43 +210,3 @@ def map_execution_command(
             raise SnowparkConnectNotImplementedError(
                 f"Command type {other} not implemented"
             )
-
-
-def _generate_random_builtin_view_name() -> str:
-    return _INTERNAL_VIEW_PREFIX + str(uuid.uuid4()).replace("-", "")
-
-
-def _is_error_caused_by_view_referencing_itself(exc: Exception) -> bool:
-    return "view definition refers to view being defined" in str(exc).lower()
-
-
-def _create_chained_view(input_df: DataFrame, view_name: str) -> None:
-    """
-    In order to create a view, which references itself, Spark would here take the previous
-    definition of A and paste it in place of `FROM A`. Snowflake would fail in such case, so
-    as a workaround, we create a chain of internal views instead. This function:
-    1. Renames previous definition of A to some internal name (instead of deleting).
-    2. Adjusts the DDL of a new statement to reference the name of a renmaed internal view, instead of itself.
-    """
-
-    session = Session.get_active_session()
-
-    view_name = ".".join(view_name)
-
-    tmp_name = _generate_random_builtin_view_name()
-    old_name_replacement = _generate_random_builtin_view_name()
-
-    input_df.create_or_replace_temp_view(tmp_name)
-
-    session.sql(f"ALTER VIEW {view_name} RENAME TO {old_name_replacement}").collect()
-
-    ddl: str = session.sql(f"SELECT GET_DDL('VIEW', '{tmp_name}')").collect()[0][0]
-
-    ddl = ddl.replace(view_name, old_name_replacement)
-
-    # GET_DDL result doesn't contain `TEMPORARY`, it's likely a bug.
-    ddl = _CREATE_VIEW_PATTERN.sub("create or replace temp view", ddl)
-
-    session.sql(ddl).collect()
-
-    session.sql(f"ALTER VIEW {tmp_name} RENAME TO {view_name}").collect()

snowflake/snowpark_connect/relation/catalogs/snowflake_catalog.py

@@ -13,7 +13,6 @@ from snowflake.core.exceptions import APIError, NotFoundError
 from snowflake.core.schema import Schema
 from snowflake.core.table import Table, TableColumn
 
-from snowflake.snowpark import functions
 from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     quote_name_without_upper_casing,
     unquote_if_quoted,
@@ -34,12 +33,19 @@ from snowflake.snowpark_connect.relation.catalogs.abstract_spark_catalog import
 )
 from snowflake.snowpark_connect.type_mapping import proto_to_snowpark_type
 from snowflake.snowpark_connect.utils.identifiers import (
+    FQN,
+    spark_to_sf_single_id_with_unquoting,
     split_fully_qualified_spark_name,
 )
 from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
+from snowflake.snowpark_connect.utils.temporary_view_cache import (
+    get_temp_view,
+    get_temp_view_normalized_names,
+    unregister_temp_view,
+)
 from snowflake.snowpark_connect.utils.udf_cache import cached_udf
 
 
@@ -203,6 +209,93 @@ class SnowflakeCatalog(AbstractSparkCatalog):
             exists = False
         return pandas.DataFrame({"exists": [exists]})
 
+    def _get_temp_view_prefixes(self, spark_dbName: str | None) -> list[str]:
+        if spark_dbName is None:
+            return []
+        return [
+            quote_name_without_upper_casing(part)
+            for part in split_fully_qualified_spark_name(spark_dbName)
+        ]
+
+    def _list_temp_views(
+        self,
+        spark_dbName: str | None = None,
+        pattern: str | None = None,
+    ) -> typing.Tuple[
+        list[str | None],
+        list[list[str | None]],
+        list[str],
+        list[str | None],
+        list[str | None],
+        list[bool],
+    ]:
+        catalogs: list[str | None] = list()
+        namespaces: list[list[str | None]] = list()
+        names: list[str] = list()
+        descriptions: list[str | None] = list()
+        table_types: list[str | None] = list()
+        is_temporaries: list[bool] = list()
+
+        temp_views_prefix = ".".join(self._get_temp_view_prefixes(spark_dbName))
+        normalized_spark_dbName = (
+            temp_views_prefix.lower()
+            if global_config.spark_sql_caseSensitive
+            else temp_views_prefix
+        )
+        normalized_global_temp_database_name = (
+            quote_name_without_upper_casing(
+                global_config.spark_sql_globalTempDatabase.lower()
+            )
+            if global_config.spark_sql_caseSensitive
+            else quote_name_without_upper_casing(
+                global_config.spark_sql_globalTempDatabase
+            )
+        )
+
+        temp_views = get_temp_view_normalized_names()
+        null_safe_pattern = pattern if pattern is not None else ""
+
+        for temp_view in temp_views:
+            normalized_temp_view = (
+                temp_view.lower()
+                if global_config.spark_sql_caseSensitive
+                else temp_view
+            )
+            fqn = FQN.from_string(temp_view)
+            normalized_schema = (
+                fqn.schema.lower()
+                if fqn.schema is not None and global_config.spark_sql_caseSensitive
+                else fqn.schema
+            )
+
+            is_global_view = normalized_global_temp_database_name == normalized_schema
+            is_local_temp_view = fqn.schema is None
+            # Temporary views are always shown if they match the pattern
+            matches_prefix = (
+                normalized_spark_dbName == normalized_schema or is_local_temp_view
+            )
+            if matches_prefix and bool(
+                re.match(null_safe_pattern, normalized_temp_view)
+            ):
+                names.append(unquote_if_quoted(fqn.name))
+                catalogs.append(None)
+                namespaces.append(
+                    [global_config.spark_sql_globalTempDatabase]
+                    if is_global_view
+                    else []
+                )
+                descriptions.append(None)
+                table_types.append("TEMPORARY")
+                is_temporaries.append(True)
+        return (
+            catalogs,
+            namespaces,
+            names,
+            descriptions,
+            table_types,
+            is_temporaries,
+        )
+
     def listTables(
         self,
         spark_dbName: str | None = None,
@@ -232,8 +325,7 @@ class SnowflakeCatalog(AbstractSparkCatalog):
             schema=sf_quote(sf_schema),
             pattern=_normalize_identifier(pattern),
         )
-        names: list[str] = list()
-        catalogs: list[str] = list()
+        catalogs: list[str | None] = list()
         namespaces: list[list[str | None]] = list()
         names: list[str] = list()
         descriptions: list[str | None] = list()
@@ -253,6 +345,22 @@ class SnowflakeCatalog(AbstractSparkCatalog):
             descriptions.append(o[6] if o[6] else None)
             table_types.append("PERMANENT")
             is_temporaries.append(False)
+
+        (
+            non_materialized_catalogs,
+            non_materialized_namespaces,
+            non_materialized_names,
+            non_materialized_descriptions,
+            non_materialized_table_types,
+            non_materialized_is_temporaries,
+        ) = self._list_temp_views(spark_dbName, pattern)
+        catalogs.extend(non_materialized_catalogs)
+        namespaces.extend(non_materialized_namespaces)
+        names.extend(non_materialized_names)
+        descriptions.extend(non_materialized_descriptions)
+        table_types.extend(non_materialized_table_types)
+        is_temporaries.extend(non_materialized_is_temporaries)
+
         return pandas.DataFrame(
             {
                 "name": names,
@@ -297,6 +405,36 @@ class SnowflakeCatalog(AbstractSparkCatalog):
         spark_tableName: str,
     ) -> pandas.DataFrame:
         """Listing a single table/view with provided name that's accessible in Snowflake."""
+
+        def _get_temp_view():
+            spark_table_name_parts = [
+                quote_name_without_upper_casing(part)
+                for part in split_fully_qualified_spark_name(spark_tableName)
+            ]
+            spark_view_name = ".".join(spark_table_name_parts)
+            temp_view = get_temp_view(spark_view_name)
+            if temp_view:
+                return pandas.DataFrame(
+                    {
+                        "name": [unquote_if_quoted(spark_table_name_parts[-1])],
+                        "catalog": [None],
+                        "namespace": [
+                            [unquote_if_quoted(spark_table_name_parts[-2])]
+                            if len(spark_table_name_parts) > 1
+                            else []
+                        ],
+                        "description": [None],
+                        "tableType": ["TEMPORARY"],
+                        "isTemporary": [True],
+                    }
+                )
+            return None
+
+        # Attempt to get the view from the non materialized views first
+        temp_view = _get_temp_view()
+        if temp_view is not None:
+            return temp_view
+
         sp_catalog = get_or_create_snowpark_session().catalog
         catalog, sf_database, sf_schema, table_name = _process_multi_layer_identifier(
             spark_tableName
@@ -360,12 +498,64 @@ class SnowflakeCatalog(AbstractSparkCatalog):
             exists = False
         return pandas.DataFrame({"exists": [exists]})
 
+    def _list_temp_view_columns(
+        self,
+        spark_tableName: str,
+        spark_dbName: typing.Optional[str] = None,
+    ):
+        spark_view_name_parts = [
+            quote_name_without_upper_casing(part)
+            for part in split_fully_qualified_spark_name(spark_tableName)
+        ]
+        spark_view_name_parts = (
+            self._get_temp_view_prefixes(spark_dbName) + spark_view_name_parts
+        )
+        spark_view_name = ".".join(spark_view_name_parts)
+        temp_view = get_temp_view(spark_view_name)
+
+        if not temp_view:
+            return None
+
+        names: list[str] = list()
+        descriptions: list[str | None] = list()
+        data_types: list[str] = list()
+        nullables: list[bool] = list()
+        is_partitions: list[bool] = list()
+        is_buckets: list[bool] = list()
+
+        for field, spark_column in zip(
+            temp_view.dataframe.schema.fields,
+            temp_view.column_map.get_spark_columns(),
+        ):
+            names.append(spark_column)
+            descriptions.append(None)
+            data_types.append(field.datatype.simpleString())
+            nullables.append(field.nullable)
+            is_partitions.append(False)
+            is_buckets.append(False)
+
+        return pandas.DataFrame(
+            {
+                "name": names,
+                "description": descriptions,
+                "dataType": data_types,
+                "nullable": nullables,
+                "isPartition": is_partitions,
+                "isBucket": is_buckets,
+            }
+        )
+
     def listColumns(
         self,
         spark_tableName: str,
         spark_dbName: typing.Optional[str] = None,
     ) -> pandas.DataFrame:
         """List all columns in a table/view, optionally database name filter can be provided."""
+
+        temp_view_columns = self._list_temp_view_columns(spark_tableName, spark_dbName)
+        if temp_view_columns is not None:
+            return temp_view_columns
+
         sp_catalog = get_or_create_snowpark_session().catalog
         columns: list[TableColumn] | None = None
         if spark_dbName is None:
@@ -455,17 +645,15 @@ class SnowflakeCatalog(AbstractSparkCatalog):
         spark_view_name: str,
     ) -> DataFrameContainer:
         session = get_or_create_snowpark_session()
-        schema = global_config.spark_sql_globalTempDatabase
-        result_df = session.sql(
-            "drop view if exists identifier(?)",
-            params=[f"{sf_quote(schema)}.{sf_quote(spark_view_name)}"],
-        )
-        result_df = result_df.select(
-            functions.contains('"status"', functions.lit("successfully dropped")).alias(
-                "value"
+        if not spark_view_name == "":
+            schema = global_config.spark_sql_globalTempDatabase
+            result = unregister_temp_view(
+                f"{spark_to_sf_single_id_with_unquoting(schema)}.{spark_to_sf_single_id_with_unquoting(spark_view_name)}"
             )
-        )
+        else:
+            result = False
         columns = ["value"]
+        result_df = session.createDataFrame([result], schema=columns)
         return DataFrameContainer.create_with_column_mapping(
             dataframe=result_df,
             spark_column_names=columns,
@@ -479,15 +667,14 @@ class SnowflakeCatalog(AbstractSparkCatalog):
     ) -> DataFrameContainer:
         """Drop the current temporary view."""
         session = get_or_create_snowpark_session()
-        result = session.sql(
-            "drop view if exists identifier(?)",
-            params=[sf_quote(spark_view_name)],
-        ).collect()
-        view_was_dropped = (
-            len(result) == 1 and "successfully dropped" in result[0]["status"]
-        )
-        result_df = session.createDataFrame([(view_was_dropped,)], schema=["value"])
         columns = ["value"]
+        if spark_view_name:
+            result = unregister_temp_view(
+                spark_to_sf_single_id_with_unquoting(spark_view_name)
+            )
+        else:
+            result = False
+        result_df = session.createDataFrame([result], schema=columns)
         return DataFrameContainer.create_with_column_mapping(
             dataframe=result_df,
             spark_column_names=columns,

snowflake/snowpark_connect/relation/map_sql.py

@@ -61,6 +61,7 @@ from snowflake.snowpark_connect.utils.context import (
     get_session_id,
     get_sql_plan,
     push_evaluating_sql_scope,
+    push_processed_view,
     push_sql_scope,
     set_plan_id_map,
     set_sql_args,
@@ -80,7 +81,16 @@ from ..expression.map_sql_expression import (
     map_logical_plan_expression,
     sql_parser,
 )
-from ..utils.identifiers import spark_to_sf_single_id
+from ..utils.identifiers import (
+    spark_to_sf_single_id,
+    spark_to_sf_single_id_with_unquoting,
+)
+from ..utils.temporary_view_cache import (
+    get_temp_view,
+    register_temp_view,
+    unregister_temp_view,
+)
+from .catalogs import SNOWFLAKE_CATALOG
 
 _ctes = ContextVar[dict[str, relation_proto.Relation]]("_ctes", default={})
 _cte_definitions = ContextVar[dict[str, any]]("_cte_definitions", default={})
@@ -403,6 +413,7 @@ def map_sql_to_pandas_df(
         ) == "UnresolvedHint":
             logical_plan = logical_plan.child()
 
+        # TODO: Add support for temporary views for SQL cases such as ShowViews, ShowColumns ect. (Currently the cases are not compatible with Spark, returning raw Snowflake rows)
         match class_name:
             case "AddColumns":
                 # Handle ALTER TABLE ... ADD COLUMNS (col_name data_type) -> ADD COLUMN col_name data_type
@@ -577,6 +588,23 @@ def map_sql_to_pandas_df(
                 )
                 snowflake_sql = parsed_sql.sql(dialect="snowflake")
                 session.sql(f"{snowflake_sql}{empty_select}").collect()
+                spark_view_name = next(
+                    sqlglot.parse_one(sql_string, dialect="spark").find_all(
+                        sqlglot.exp.Table
+                    )
+                ).name
+                snowflake_view_name = spark_to_sf_single_id_with_unquoting(
+                    spark_view_name
+                )
+                temp_view = get_temp_view(snowflake_view_name)
+                if temp_view is not None and not logical_plan.replace():
+                    raise AnalysisException(
+                        f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{spark_view_name}` because it already exists."
+                    )
+                else:
+                    unregister_temp_view(
+                        spark_to_sf_single_id_with_unquoting(spark_view_name)
+                    )
             case "CreateView":
                 current_schema = session.connection.schema
                 if (
@@ -613,50 +641,60 @@ def map_sql_to_pandas_df(
                     else None,
                 )
             case "CreateViewCommand":
-                df_container = execute_logical_plan(logical_plan.plan())
-                df = df_container.dataframe
-                tmp_views = _get_current_temp_objects()
-                tmp_views.add(
-                    (
-                        CURRENT_CATALOG_NAME,
-                        session.connection.schema,
-                        str(logical_plan.name().identifier()),
+                with push_processed_view(logical_plan.name().identifier()):
+                    df_container = execute_logical_plan(logical_plan.plan())
+                    df = df_container.dataframe
+                    user_specified_spark_column_names = [
+                        str(col._1())
+                        for col in as_java_list(logical_plan.userSpecifiedColumns())
+                    ]
+                    df_container = DataFrameContainer.create_with_column_mapping(
+                        dataframe=df,
+                        spark_column_names=user_specified_spark_column_names
+                        if user_specified_spark_column_names
+                        else df_container.column_map.get_spark_columns(),
+                        snowpark_column_names=df_container.column_map.get_snowpark_columns(),
+                        parent_column_name_map=df_container.column_map,
                     )
-                )
-
-                name = str(logical_plan.name().identifier())
-                name = spark_to_sf_single_id(name)
-                if isinstance(
-                    logical_plan.viewType(),
-                    jpype.JClass(
-                        "org.apache.spark.sql.catalyst.analysis.GlobalTempView$"
-                    ),
-                ):
-                    name = f"{global_config.spark_sql_globalTempDatabase}.{name}"
-                comment = logical_plan.comment()
-                maybe_comment = (
-                    _escape_sql_comment(str(comment.get()))
-                    if comment.isDefined()
-                    else None
-                )
-
-                df = _rename_columns(
-                    df, logical_plan.userSpecifiedColumns(), df_container.column_map
-                )
-
-                if logical_plan.replace():
-                    df.create_or_replace_temp_view(
-                        name,
-                        comment=maybe_comment,
+                    is_global = isinstance(
+                        logical_plan.viewType(),
+                        jpype.JClass(
+                            "org.apache.spark.sql.catalyst.analysis.GlobalTempView$"
+                        ),
                     )
-                else:
-                    df.create_temp_view(
-                        name,
-                        comment=maybe_comment,
+                    if is_global:
+                        view_name = [
+                            global_config.spark_sql_globalTempDatabase,
+                            logical_plan.name().quotedString(),
+                        ]
+                    else:
+                        view_name = [logical_plan.name().quotedString()]
+                    view_name = [
+                        spark_to_sf_single_id_with_unquoting(part) for part in view_name
+                    ]
+                    joined_view_name = ".".join(view_name)
+
+                    register_temp_view(
+                        joined_view_name,
+                        df_container,
+                        logical_plan.replace(),
+                    )
+                    tmp_views = _get_current_temp_objects()
+                    tmp_views.add(
+                        (
+                            CURRENT_CATALOG_NAME,
+                            session.connection.schema,
+                            str(logical_plan.name().identifier()),
+                        )
                     )
             case "DescribeColumn":
-                name = get_relation_identifier_name(logical_plan.column())
+                name = get_relation_identifier_name_without_uppercasing(
+                    logical_plan.column()
+                )
+                if get_temp_view(name):
+                    return SNOWFLAKE_CATALOG.listColumns(unquote_if_quoted(name)), ""
                 # todo double check if this is correct
+                name = get_relation_identifier_name(logical_plan.column())
                 rows = session.sql(f"DESCRIBE TABLE {name}").collect()
             case "DescribeNamespace":
                 name = get_relation_identifier_name(logical_plan.namespace(), True)
@@ -731,9 +769,13 @@ def map_sql_to_pandas_df(
                 if_exists = "IF EXISTS " if logical_plan.ifExists() else ""
                 session.sql(f"DROP TABLE {if_exists}{name}").collect()
             case "DropView":
-                name = get_relation_identifier_name(logical_plan.child())
-                if_exists = "IF EXISTS " if logical_plan.ifExists() else ""
-                session.sql(f"DROP VIEW {if_exists}{name}").collect()
+                temporary_view_name = get_relation_identifier_name_without_uppercasing(
+                    logical_plan.child()
+                )
+                if not unregister_temp_view(temporary_view_name):
+                    name = get_relation_identifier_name(logical_plan.child())
+                    if_exists = "IF EXISTS " if logical_plan.ifExists() else ""
+                    session.sql(f"DROP VIEW {if_exists}{name}").collect()
             case "ExplainCommand":
                 inner_plan = logical_plan.logicalPlan()
                 logical_plan_name = inner_plan.nodeName()
@@ -2173,21 +2215,38 @@ def map_logical_plan_relation(
     return proto
 
 
-def get_relation_identifier_name(name_obj, is_multi_part: bool = False) -> str:
+def _get_relation_identifier(name_obj) -> str:
+    # IDENTIFIER(<table_name>), or IDENTIFIER(<method name>)
+    expr_proto = map_logical_plan_expression(name_obj.identifierExpr())
+    session = snowpark.Session.get_active_session()
+    m = ColumnNameMap([], [], None)
+    expr = map_single_column_expression(
+        expr_proto, m, ExpressionTyper.dummy_typer(session)
+    )
+    return spark_to_sf_single_id(session.range(1).select(expr[1].col).collect()[0][0])
+
+
+def get_relation_identifier_name_without_uppercasing(name_obj) -> str:
     if name_obj.getClass().getSimpleName() in (
         "PlanWithUnresolvedIdentifier",
         "ExpressionWithUnresolvedIdentifier",
     ):
-        # IDENTIFIER(<table_name>), or IDENTIFIER(<method name>)
-        expr_proto = map_logical_plan_expression(name_obj.identifierExpr())
-        session = snowpark.Session.get_active_session()
-        m = ColumnNameMap([], [], None)
-        expr = map_single_column_expression(
-            expr_proto, m, ExpressionTyper.dummy_typer(session)
-        )
-        name = spark_to_sf_single_id(
-            session.range(1).select(expr[1].col).collect()[0][0]
+        return _get_relation_identifier(name_obj)
+    else:
+        name = ".".join(
+            quote_name_without_upper_casing(str(part))
+            for part in as_java_list(name_obj.nameParts())
         )
+
+    return name
+
+
+def get_relation_identifier_name(name_obj, is_multi_part: bool = False) -> str:
+    if name_obj.getClass().getSimpleName() in (
+        "PlanWithUnresolvedIdentifier",
+        "ExpressionWithUnresolvedIdentifier",
+    ):
+        return _get_relation_identifier(name_obj)
     else:
         if is_multi_part:
             try:

snowflake/snowpark_connect/relation/read/map_read_table.py

@@ -11,11 +11,17 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     unquote_if_quoted,
 )
 from snowflake.snowpark.exceptions import SnowparkSQLException
+from snowflake.snowpark.types import StructField, StructType
+from snowflake.snowpark_connect.column_name_handler import (
+    ColumnNameMap,
+    make_column_names_snowpark_compatible,
+)
 from snowflake.snowpark_connect.config import auto_uppercase_non_column_identifiers
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.read.utils import (
     rename_columns_as_snowflake_standard,
 )
+from snowflake.snowpark_connect.utils.context import get_processed_views
 from snowflake.snowpark_connect.utils.identifiers import (
     split_fully_qualified_spark_name,
 )
@@ -23,6 +29,7 @@ from snowflake.snowpark_connect.utils.session import _get_current_snowpark_sessi
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
+from snowflake.snowpark_connect.utils.temporary_view_cache import get_temp_view
 
 
 def post_process_df(
@@ -64,15 +71,66 @@ def post_process_df(
         raise
 
 
+def _get_temporary_view(
+    temp_view: DataFrameContainer, table_name: str, plan_id: int
+) -> DataFrameContainer:
+    fields_names = [field.name for field in temp_view.dataframe.schema.fields]
+    fields_types = [field.datatype for field in temp_view.dataframe.schema.fields]
+
+    snowpark_column_names = make_column_names_snowpark_compatible(fields_names, plan_id)
+    # Rename columns in dataframe to prevent conflicting names during joins
+    renamed_df = temp_view.dataframe.select(
+        *(
+            temp_view.dataframe.col(orig).alias(alias)
+            for orig, alias in zip(fields_names, snowpark_column_names)
+        )
+    )
+
+    new_column_map = ColumnNameMap(
+        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()),
+        parent_column_name_map=temp_view.column_map.get_parent_column_name_map(),
+    )
+
+    schema = StructType(
+        [
+            StructField(name, type, _is_column=False)
+            for name, type in zip(snowpark_column_names, fields_types)
+        ]
+    )
+    return DataFrameContainer(
+        dataframe=renamed_df,
+        column_map=new_column_map,
+        table_name=temp_view.table_name,
+        alias=temp_view.alias,
+        partition_hint=temp_view.partition_hint,
+        cached_schema_getter=lambda: schema,
+    )
+
+
 def get_table_from_name(
     table_name: str, session: snowpark.Session, plan_id: int
 ) -> DataFrameContainer:
     """Get table from name returning a container."""
+
+    # Verify if recursive view read is not attempted
+    if table_name in get_processed_views():
+        raise AnalysisException(
+            f"[RECURSIVE_VIEW] Recursive view `{table_name}` detected (cycle: `{table_name}` -> `{table_name}`)"
+        )
+
     snowpark_name = ".".join(
         quote_name_without_upper_casing(part)
         for part in split_fully_qualified_spark_name(table_name)
     )
 
+    temp_view = get_temp_view(snowpark_name)
+    if temp_view:
+        return _get_temporary_view(temp_view, table_name, plan_id)
+
     if auto_uppercase_non_column_identifiers():
         snowpark_name = snowpark_name.upper()
 

snowflake/snowpark_connect/relation/write/map_write.py

@@ -218,8 +218,9 @@ def map_write(request: proto_base.ExecutePlanRequest):
                 },
                 "overwrite": overwrite,
             }
-            # By default, download from the same prefix we wrote to.
-            download_stage_path = temp_file_prefix_on_stage
+            # Download from the base write path to ensure we fetch whatever Snowflake produced.
+            # Using the base avoids coupling to exact filenames/prefixes.
+            download_stage_path = write_path
 
             # Check for partition hint early to determine precedence over single option
             partition_hint = result.partition_hint
@@ -238,13 +239,19 @@ def map_write(request: proto_base.ExecutePlanRequest):
                     raise SnowparkConnectNotImplementedError(
                         "Partitioning is only supported for parquet format"
                     )
-                partitioning_columns = [f'"{c}"' for c in write_op.partitioning_columns]
-                if len(partitioning_columns) > 1:
-                    raise SnowparkConnectNotImplementedError(
-                        "Multiple partitioning columns are not yet supported"
-                    )
-                else:
-                    parameters["partition_by"] = partitioning_columns[0]
+                # Build Spark-style directory structure: col1=value1/col2=value2/...
+                # Example produced expression (Snowflake SQL):
+                #   'department=' || TO_VARCHAR("department") || '/' || 'region=' || TO_VARCHAR("region")
+                partitioning_column_names = list(write_op.partitioning_columns)
+                partition_expr_parts: list[str] = []
+                for col_name in partitioning_column_names:
+                    quoted = f'"{col_name}"'
+                    segment = f"'{col_name}=' || COALESCE(TO_VARCHAR({quoted}), '__HIVE_DEFAULT_PARTITION__')"
+                    partition_expr_parts.append(segment)
+                parameters["partition_by"] = " || '/' || ".join(partition_expr_parts)
+                # When using PARTITION BY, Snowflake writes into subdirectories under the base path.
+                # Download from the base write path to preserve partition directories locally.
+                download_stage_path = write_path
 
             # If a partition hint is present (from DataFrame.repartition(n)), optionally split the
             # write into n COPY INTO calls by assigning a synthetic partition id. Controlled by config.
@@ -978,7 +985,47 @@ def store_files_locally(
     )
     if overwrite and os.path.isdir(target_path):
         _truncate_directory(real_path)
-    snowpark.file_operation.FileOperation(session).get(stage_path, str(real_path))
+    # Per Snowflake docs: "The command does not preserve stage directory structure when transferring files to your client machine"
+    # https://docs.snowflake.com/en/sql-reference/sql/get
+    # Preserve directory structure under stage_path by listing files and
+    # downloading each into its corresponding local subdirectory when partition subdirs exist.
+    # Otherwise, fall back to a direct GET which flattens.
+
+    # TODO(SNOW-2326973): This can be parallelized further. Its not done here because it only affects
+    # write to local storage.
+
+    ls_dataframe = session.sql(f"LS {stage_path}")
+    ls_iterator = ls_dataframe.toLocalIterator()
+
+    # Build a normalized base prefix from stage_path to compute relatives
+    # Example: stage_path='@MY_STAGE/prefix' -> base_prefix='my_stage/prefix/'
+    base_prefix = stage_path.lstrip("@").rstrip("/") + "/"
+    base_prefix_lower = base_prefix.lower()
+
+    # Group by parent directory under the base prefix, then issue a GET per directory.
+    # This gives a small parallelism advantage if we have many files per partition directory.
+    parent_dirs: set[str] = set()
+    for row in ls_iterator:
+        name: str = row[0]
+        name_lower = name.lower()
+        rel_start = name_lower.find(base_prefix_lower)
+        relative = name[rel_start + len(base_prefix) :] if rel_start != -1 else name
+        parent_dir = os.path.dirname(relative)
+        if parent_dir and parent_dir != ".":
+            parent_dirs.add(parent_dir)
+
+    # If no parent directories were discovered (non-partitioned unload prefix), use direct GET.
+    if not parent_dirs:
+        snowpark.file_operation.FileOperation(session).get(stage_path, str(real_path))
+        return
+
+    file_op = snowpark.file_operation.FileOperation(session)
+    for parent_dir in sorted(parent_dirs):
+        local_dir = real_path / parent_dir
+        os.makedirs(local_dir, exist_ok=True)
+
+        src_dir = f"@{base_prefix}{parent_dir}"
+        file_op.get(src_dir, str(local_dir))
 
 
 def _truncate_directory(directory_path: Path) -> None:

snowflake/snowpark_connect/utils/context.py

@@ -70,6 +70,26 @@ _lca_alias_map: ContextVar[dict[str, TypedColumn]] = ContextVar(
     default={},
 )
 
+_view_process_context = ContextVar("_view_process_context", default=[])
+
+
+@contextmanager
+def push_processed_view(name: str):
+    _view_process_context.set(_view_process_context.get() + [name])
+    yield
+    _view_process_context.set(_view_process_context.get()[:-1])
+
+
+def get_processed_views() -> list[str]:
+    return _view_process_context.get()
+
+
+def register_processed_view(name: str) -> None:
+    context = _view_process_context.get()
+    context.append(name)
+    _view_process_context.set(context)
+
+
 # Context variable to track current grouping columns for grouping_id() function
 _current_grouping_columns: ContextVar[list[str]] = ContextVar(
     "_current_grouping_columns",
@@ -387,6 +407,7 @@ def clear_context_data() -> None:
     _plan_id_map.set({})
     _alias_map.set({})
 
+    _view_process_context.set([])
     _next_sql_plan_id.set(_STARTING_SQL_PLAN_ID)
     _sql_plan_name_map.set({})
     _map_partitions_stack.set(0)

snowflake/snowpark_connect/utils/identifiers.py

@@ -28,12 +28,18 @@ def unquote_spark_identifier_if_quoted(spark_name: str) -> str:
     raise AnalysisException(f"Invalid name: {spark_name}")
 
 
-def spark_to_sf_single_id_with_unquoting(name: str) -> str:
+def spark_to_sf_single_id_with_unquoting(
+    name: str, use_auto_upper_case: bool = False
+) -> str:
     """
     Transforms a spark name to a valid snowflake name by quoting and potentially uppercasing it.
     Unquotes the spark name if necessary. Will raise an AnalysisException if given name is not valid.
     """
-    return spark_to_sf_single_id(unquote_spark_identifier_if_quoted(name))
+    return (
+        spark_to_sf_single_id(unquote_spark_identifier_if_quoted(name))
+        if use_auto_upper_case
+        else quote_name_without_upper_casing(unquote_spark_identifier_if_quoted(name))
+    )
 
 
 def spark_to_sf_single_id(name: str, is_column: bool = False) -> str:

snowflake/snowpark_connect/utils/temporary_view_cache.py

@@ -0,0 +1,61 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from typing import Optional, Tuple
+
+from pyspark.errors import AnalysisException
+
+from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
+from snowflake.snowpark_connect.utils.concurrent import SynchronizedDict
+from snowflake.snowpark_connect.utils.context import get_session_id
+
+_temp_views = SynchronizedDict[Tuple[str, str], DataFrameContainer]()
+
+
+def register_temp_view(name: str, df: DataFrameContainer, replace: bool) -> None:
+    normalized_name = _normalize(name)
+    current_session_id = get_session_id()
+    for key in list(_temp_views.keys()):
+        if _normalize(key[0]) == normalized_name and key[1] == current_session_id:
+            if replace:
+                _temp_views.remove(key)
+                break
+            else:
+                raise AnalysisException(
+                    f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{name}` because it already exists."
+                )
+
+    _temp_views[(name, current_session_id)] = df
+
+
+def unregister_temp_view(name: str) -> bool:
+    normalized_name = _normalize(name)
+
+    for key in _temp_views.keys():
+        normalized_key = _normalize(key[0])
+        if normalized_name == normalized_key and key[1] == get_session_id():
+            pop_result = _temp_views.remove(key)
+            return pop_result is not None
+    return False
+
+
+def get_temp_view(name: str) -> Optional[DataFrameContainer]:
+    normalized_name = _normalize(name)
+    for key in _temp_views.keys():
+        normalized_key = _normalize(key[0])
+        if normalized_name == normalized_key and key[1] == get_session_id():
+            return _temp_views.get(key)
+    return None
+
+
+def get_temp_view_normalized_names() -> list[str]:
+    return [
+        _normalize(key[0]) for key in _temp_views.keys() if key[1] == get_session_id()
+    ]
+
+
+def _normalize(name: str) -> str:
+    from snowflake.snowpark_connect.config import global_config
+
+    return name if global_config.spark_sql_caseSensitive else name.lower()

snowflake/snowpark_connect/utils/udf_utils.py

@@ -176,14 +176,6 @@ class ProcessCommonInlineUserDefinedFunction:
                         tar_ref.extractall(archive[: -len(".archive")])
                 os.remove(archive)
 
-        def callable_func(*args, **kwargs):
-            import_staged_files()
-            return original_callable(*args, **kwargs)
-
-        callable_func.__signature__ = inspect.signature(original_callable)
-        if hasattr(original_callable, "__annotations__"):
-            callable_func.__annotations__ = original_callable.__annotations__
-
         if self._udf_packages:
             packages = [p.strip() for p in self._udf_packages.strip("[]").split(",")]
         else:
@@ -193,6 +185,15 @@ class ProcessCommonInlineUserDefinedFunction:
         else:
             imports = []
 
+        def callable_func(*args, **kwargs):
+            if imports:
+                import_staged_files()
+            return original_callable(*args, **kwargs)
+
+        callable_func.__signature__ = inspect.signature(original_callable)
+        if hasattr(original_callable, "__annotations__"):
+            callable_func.__annotations__ = original_callable.__annotations__
+
         update_none_input_types()
 
         needs_struct_conversion = isinstance(self._original_return_type, StructType)

snowflake/snowpark_connect/utils/udtf_utils.py

@@ -38,8 +38,9 @@ def create_udtf(
     # We subtract one here since UDTF functions are class methods and always have "self" as the first parameter.
     input_types = [VariantType()] * (len(func_signature.parameters) - 1)
 
-    # Wrapp callable to allow reading imported files
-    callable_func = artifacts_reader_wrapper(callable_func)
+    if imports:
+        # Wrapp callable to allow reading imported files
+        callable_func = artifacts_reader_wrapper(callable_func)
 
     if is_arrow_enabled:
         callable_func = spark_compatible_udtf_wrapper_with_arrow(

snowflake/snowpark_connect/version.py

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

{snowpark_connect-0.28.0.dist-info → snowpark_connect-0.28.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.28.0
+Version: 0.28.1
 Summary: Snowpark Connect for Spark
 Author: Snowflake, Inc
 License: Apache License, Version 2.0

{snowpark_connect-0.28.0.dist-info → snowpark_connect-0.28.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 snowflake/snowpark_connect/__init__.py,sha256=Sml4x1LTNnxZyw6nnDeJrZWUi3eUAR46Rsw6N-wHUSA,605
 snowflake/snowpark_connect/column_name_handler.py,sha256=_Z2j4teR_3nsCLjMxhyChGmds_1v6tP51OfkEpmWXWk,27164
-snowflake/snowpark_connect/config.py,sha256=vfuM2TBuuoBe_y9Y_utPelU-9hLoVE-lJszmN8vT5qw,28145
+snowflake/snowpark_connect/config.py,sha256=B2TeNqpfFy2ObjuUhgBNOhQ0Knxc7ZYiI7doOSkuSFw,28146
 snowflake/snowpark_connect/constants.py,sha256=FBDxNUxdqWxnf6d5-eanHlYdFFyQqCqvNyZG-uOiO6Q,598
 snowflake/snowpark_connect/control_server.py,sha256=mz3huYo84hgqUB6maZxu3LYyGq7vVL1nv7-7-MjuSYY,1956
 snowflake/snowpark_connect/dataframe_container.py,sha256=0ozyUXrWErzM7Gltnb-i2o5ZyXVVeT_HCqpuYliQXwc,8798
@@ -13,7 +13,7 @@ snowflake/snowpark_connect/start_server.py,sha256=udegO0rk2FeSnXsIcCIYQW3VRlGDjB
 snowflake/snowpark_connect/tcm.py,sha256=ftncZFbVO-uyWMhF1_HYKQykB7KobHEYoyQsYbQj1EM,203
 snowflake/snowpark_connect/type_mapping.py,sha256=6Hg-h1iVzVB_FnwG3Sjl-UGr2Itrs4LxVb2Pz5Ue-YA,41566
 snowflake/snowpark_connect/typed_column.py,sha256=Tavii8b4zMj5IWOvN6tlOVmC80W6eQct0pC_tF2nlhU,3867
-snowflake/snowpark_connect/version.py,sha256=h25IrA984uyrAk0fG8Iy3TJC7b-VG1YTDkoW-sfpxDU,118
+snowflake/snowpark_connect/version.py,sha256=174Rf6GxIIk1u2aUG821BNtN-OKC59qCc6Nc3xldSWw,118
 snowflake/snowpark_connect/analyze_plan/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
 snowflake/snowpark_connect/analyze_plan/map_tree_string.py,sha256=Q3ZD-Z7uForrF7W3mSAjwaiEcIv2KDXr5jPfVbromVg,1470
 snowflake/snowpark_connect/error/__init__.py,sha256=oQo6k4zztLmNF1c5IvJLcS99J6RWY9KBTN3RJ2pKimg,249
@@ -21,7 +21,7 @@ snowflake/snowpark_connect/error/error_mapping.py,sha256=vdnLOU1Sqpocpu_uCXjfhiv
 snowflake/snowpark_connect/error/error_utils.py,sha256=Sb_p5dsrFZsLrR9B_Tp8d80Z6KcPtz9OM40lNbgsgRI,14863
 snowflake/snowpark_connect/error/exceptions.py,sha256=EOnTDiJZuVJ9dNBzy5cK0OBprbYCD3gWTCCLITjd1mY,677
 snowflake/snowpark_connect/execute_plan/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
-snowflake/snowpark_connect/execute_plan/map_execution_command.py,sha256=Sm3xF9-pQJMmPQY97-BXxfV7oytY_aPLViBDOeE34nQ,10354
+snowflake/snowpark_connect/execute_plan/map_execution_command.py,sha256=j3XjBAwqOHY3D2cwu7Ez2jSZq57UUbal-1ynwXnrOHM,9355
 snowflake/snowpark_connect/execute_plan/map_execution_root.py,sha256=wFxeSxtuQY1OmI_BRLOzudrGwkJsmbBUOFQfsxxvRrU,7461
 snowflake/snowpark_connect/execute_plan/utils.py,sha256=OsjEd-WnQEX2oNVvlzGR6rpJVYyfxx1LACP09k1Y4lk,7830
 snowflake/snowpark_connect/expression/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
@@ -408,7 +408,7 @@ snowflake/snowpark_connect/relation/map_relation.py,sha256=etQ_SGXAAXNZxqfG6ouh6
 snowflake/snowpark_connect/relation/map_row_ops.py,sha256=x1Jqircy4I0iiSljx3zbq0YxwGvGzPcXIY8_nhtl2PM,30528
 snowflake/snowpark_connect/relation/map_sample_by.py,sha256=8ALQbeUsB89sI3uiUFqG3w1A4TtOzOAL4umdKp6-c38,1530
 snowflake/snowpark_connect/relation/map_show_string.py,sha256=GgKg0qp1pGqSC7TuFedTU4IYaIm-Fx23OJ1LfkcGOHw,3382
-snowflake/snowpark_connect/relation/map_sql.py,sha256=BvGVUG2fH_oyym8DVoMXnJy4Zzi_hSy-wa-x1xcapTE,101175
+snowflake/snowpark_connect/relation/map_sql.py,sha256=7LeobApI0Pfvb1D2rSJYFMjyD6PMJ8Ig4Frcxv_k0Bc,104069
 snowflake/snowpark_connect/relation/map_stats.py,sha256=kqRYvix8RfluTKx1cAy9JhBUv6arYQHgfxpP1R4QwBM,13985
 snowflake/snowpark_connect/relation/map_subquery_alias.py,sha256=rHgE9XUzuWWkjNPtJz3Sxzz2aFo690paHKZh9frqPXk,1456
 snowflake/snowpark_connect/relation/map_udtf.py,sha256=cfDnbZ3TRJ6eb0EVResu6GL-OwQpaEabWLbrhgWnkRw,13316
@@ -416,7 +416,7 @@ snowflake/snowpark_connect/relation/stage_locator.py,sha256=c30Z4N_xFavaL5XhIl9s
 snowflake/snowpark_connect/relation/utils.py,sha256=AhE58g0Zz2DWY9gW4JnB_iBU-r4RMnWCj4okQdHSz_4,8398
 snowflake/snowpark_connect/relation/catalogs/__init__.py,sha256=0yJ5Nfg7SIxudI0P7_U5EWPyiTpkMet8tSq-IwutSZo,265
 snowflake/snowpark_connect/relation/catalogs/abstract_spark_catalog.py,sha256=wujeuKotJZRzpPp_WqVB9TkfprFU2tIXTQJk_eFOR0o,9826
-snowflake/snowpark_connect/relation/catalogs/snowflake_catalog.py,sha256=bsE4XSYd0AjMTAQh8M6NIiOidlCylcQOaIFjGm0EkRw,21802
+snowflake/snowpark_connect/relation/catalogs/snowflake_catalog.py,sha256=e9rXL0DOAf4VBZfa-idqehLAEZoCgIoE4IDiLVvR4dQ,28475
 snowflake/snowpark_connect/relation/catalogs/utils.py,sha256=AgiBkK9Xwm9ZyjsKZYK9eTb4YZ9C5dAimD9DLlft-tY,1753
 snowflake/snowpark_connect/relation/read/__init__.py,sha256=5J3IOTKu4Qmenouz1Oz_bUu_4c6KpxtaC63mPUGLyeY,132
 snowflake/snowpark_connect/relation/read/jdbc_read_dbapi.py,sha256=nwvBYwdDTRQc8ljt4CLLaVl5M2uei1TDICJkz7CDSG8,24608
@@ -426,24 +426,24 @@ snowflake/snowpark_connect/relation/read/map_read_jdbc.py,sha256=rfuf2Gp89v-9YFh
 snowflake/snowpark_connect/relation/read/map_read_json.py,sha256=z6xdXNCFOfRbZ-6J4QQ2wB7ad6vEm8S1H7T3Xx5CBck,12371
 snowflake/snowpark_connect/relation/read/map_read_parquet.py,sha256=VIUR5GWP6DBaYCDUsrDJzHQOM3y4hIbtWiCx0f4mczs,7168
 snowflake/snowpark_connect/relation/read/map_read_socket.py,sha256=yg7aO7jXMOyLQ9k3-abywNN2VAgvtvix2V8LsR_XQO4,2267
-snowflake/snowpark_connect/relation/read/map_read_table.py,sha256=gdUgdXVNKugLFHec2guP0eRd4Lu-XUOujLvyCKvrr7w,4354
+snowflake/snowpark_connect/relation/read/map_read_table.py,sha256=mlbC4mbsV4_mHxYpxkOJ8nr8aNwEh2xBzfzC07XXaCQ,6607
 snowflake/snowpark_connect/relation/read/map_read_text.py,sha256=Vcm6EY3gyRPucdAXcXcu2mREcgq4N_4h3NDKNPhqsHY,3434
 snowflake/snowpark_connect/relation/read/reader_config.py,sha256=PMh1R5IjqqTwiAAqvDRhnTx8Jxnhq8wVCmpZRqqKD3E,16437
 snowflake/snowpark_connect/relation/read/utils.py,sha256=rIIM6d2WXHh7MLGyHNiRc9tS8b0dmyFQr7rHepIYJOU,4111
 snowflake/snowpark_connect/relation/write/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
 snowflake/snowpark_connect/relation/write/jdbc_write_dbapi.py,sha256=GI9FyGZuQQNV-6Q8Ob-Xr0im3iAPdH-Jkyx8bjwbOuE,11931
-snowflake/snowpark_connect/relation/write/map_write.py,sha256=zHWjjzYxj4rNPzybFYPnCK3mUSJMjmXv2FMiMAG0krY,43014
+snowflake/snowpark_connect/relation/write/map_write.py,sha256=swxSLYq4P1B3Yj7Spruw-vaBE1z-Q-er4iScuPqVyxc,45606
 snowflake/snowpark_connect/relation/write/map_write_jdbc.py,sha256=1nOWRgjtZzfRwnSRGFP9V6mqBVlGhSBr2KHGHbe4JMU,1404
 snowflake/snowpark_connect/resources/java_udfs-1.0-SNAPSHOT.jar,sha256=tVyOp6tXxu9nm6SDufwQiGzfH3pnuh_7PowsMZxOolY,9773
 snowflake/snowpark_connect/utils/__init__.py,sha256=xsIE96jDASko3F-MeNf4T4Gg5ufthS8CejeiJDfri0M,76
 snowflake/snowpark_connect/utils/artifacts.py,sha256=TkHZ2uNfZiphgtG91V1_c_h9yP9dP677BXUMymboCss,2498
 snowflake/snowpark_connect/utils/cache.py,sha256=bAyoNBW6Z1ui9BuppDywbQeG6fdju4L-owFHzySOTnk,3382
 snowflake/snowpark_connect/utils/concurrent.py,sha256=BTbUmvupLzUSRd6L7kKk9yIXFdqlDOkXebVMaECRD-A,3653
-snowflake/snowpark_connect/utils/context.py,sha256=W9j9eC-lbGp7tfXWhnvI88CVOcLGspYEhEgxGPYVbYE,13288
+snowflake/snowpark_connect/utils/context.py,sha256=yJ0pun5I69xu3__s39XX5LdQjqIEezFCgo1A-FhiWJ8,13829
 snowflake/snowpark_connect/utils/describe_query_cache.py,sha256=HByBsP-XJ1PAk414OQtwIqcFnqpC2zq-ZK_YxR4O5gg,9100
 snowflake/snowpark_connect/utils/env_utils.py,sha256=g__Uio5ae20Tm1evahIHdJUXQYPmjNUT_kYPSIy5JDU,1488
 snowflake/snowpark_connect/utils/external_udxf_cache.py,sha256=eSZHMbjTxnkg78IlbG5P1Vno6j5ag_FSI0c4Xi2UyPs,1044
-snowflake/snowpark_connect/utils/identifiers.py,sha256=A65-aQpuhTjOjGv0cmlE8fTNCI9_ONn-AYatKb_VfGM,7635
+snowflake/snowpark_connect/utils/identifiers.py,sha256=yHsOklj6SM2re5auhSSMLPSvCYhpR8Cgy-Kgevf8gDc,7810
 snowflake/snowpark_connect/utils/interrupt.py,sha256=_awhdrzF1KQO-EQThneEcfMg3Zxed4p3HtMpkcAb6ek,2790
 snowflake/snowpark_connect/utils/io_utils.py,sha256=xu0AMrHy-qsY7TfdIxzWChf0hU_7bnvm3Ruk0XScRns,1781
 snowflake/snowpark_connect/utils/pandas_udtf_utils.py,sha256=3WA_9IVRZL8fnwIHo048LTg62-bPGfCDUZzYd-zjzQQ,7564
@@ -452,11 +452,12 @@ snowflake/snowpark_connect/utils/scala_udf_utils.py,sha256=RFDDMmgQ_xBWk98kdfWaw
 snowflake/snowpark_connect/utils/session.py,sha256=BWwpIbhdplQOhvY4GpbLgZ-BrJLidrWR6A_cJmGFCq8,7372
 snowflake/snowpark_connect/utils/snowpark_connect_logging.py,sha256=23bvbALGqixJ3Ap9QWM3OpcKNK-sog2mr9liSmvwqYU,1123
 snowflake/snowpark_connect/utils/telemetry.py,sha256=4TImrE4XY5rfiesHyPQQ0xtU63qnN1wUpDXUP12PAvA,22259
+snowflake/snowpark_connect/utils/temporary_view_cache.py,sha256=M1czwb-uv0nP9w1meB72NR7cj0iryJc_OYFPztx5XuU,2080
 snowflake/snowpark_connect/utils/udf_cache.py,sha256=8K7kASEhvpnp-l1hjzovjyboUzKctDq7PiGXRcNv6Lg,12125
 snowflake/snowpark_connect/utils/udf_helper.py,sha256=g-TxTs4ARyJWYgADrosfQQG-ykBBQdm1g5opslxJq_E,12563
-snowflake/snowpark_connect/utils/udf_utils.py,sha256=pxERcJKum2M5jHxPqsl1NgHFAqZV4RxoEnSLxJV5ups,12009
+snowflake/snowpark_connect/utils/udf_utils.py,sha256=aQX58P2f9WuJDAuoT5Ag5MNTZVxcx4NIZg_UJhcfW7k,12037
 snowflake/snowpark_connect/utils/udtf_helper.py,sha256=9B_1iOckfFXQfVv-UHerIJ32fDd4qucKaHGqxtBEi4w,14969
-snowflake/snowpark_connect/utils/udtf_utils.py,sha256=wHO5V0BXRQOLqAYos1vGt8bbdH7jBvD2gwspWywjTtY,33110
+snowflake/snowpark_connect/utils/udtf_utils.py,sha256=7pYIOHUn7BLzQPqOqGaBOlV4fOnVIrWpd61quYuZ9PI,33134
 snowflake/snowpark_connect/utils/udxf_import_utils.py,sha256=pPtcaGsyh0tUdy0aAvNqTj04jqPKlEcGmvaZDP9O8Gc,536
 snowflake/snowpark_connect/utils/xxhash64.py,sha256=ysJRxhBPf25LeNhM1RK_H36MWl6q6C6vBRHa-jIna_A,7477
 snowflake/snowpark_decoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -464,17 +465,17 @@ snowflake/snowpark_decoder/dp_session.py,sha256=HIr3TfKgYl5zqaGR5xpFU9ZVkcaTB9I8
 snowflake/snowpark_decoder/spark_decoder.py,sha256=EQiCvBiqB736Bc17o3gnYGtcYVcyfGxroO5e1kbe1Co,2885
 snowflake/snowpark_decoder/_internal/proto/generated/DataframeProcessorMsg_pb2.py,sha256=2eSDqeyfMvmIJ6_rF663DrEe1dg_anrP4OpVJNTJHaQ,2598
 snowflake/snowpark_decoder/_internal/proto/generated/DataframeProcessorMsg_pb2.pyi,sha256=aIH23k52bXdw5vO3RtM5UcOjDPaWsJFx1SRUSk3qOK8,6142
-snowpark_connect-0.28.0.data/scripts/snowpark-connect,sha256=yZ94KqbWACxnwV8mpg8NjILvvRNjnF8B3cs3ZFNuIM4,1546
-snowpark_connect-0.28.0.data/scripts/snowpark-session,sha256=NMAHSonTo-nmOZSkQNlszUC0jLJ8QWEDUsUmMe2UAOw,190
-snowpark_connect-0.28.0.data/scripts/snowpark-submit,sha256=Zd98H9W_d0dIqMSkQLdHyW5G3myxF0t4c3vNBt2nD6A,12056
-snowpark_connect-0.28.0.dist-info/licenses/LICENSE-binary,sha256=fmBlX39HwTlBUyiKEznaLZGuxQy-7ndLLG_rTXjF02Y,22916
-snowpark_connect-0.28.0.dist-info/licenses/LICENSE.txt,sha256=Ff9cPv4xu0z7bnMTHzo4vDncOShsy33w4oJMA2xjn6c,11365
-snowpark_connect-0.28.0.dist-info/licenses/NOTICE-binary,sha256=elMF8brgGNJwOz8YdorzBF6-U8ZhR8F-77FfGkZng7U,57843
+snowpark_connect-0.28.1.data/scripts/snowpark-connect,sha256=yZ94KqbWACxnwV8mpg8NjILvvRNjnF8B3cs3ZFNuIM4,1546
+snowpark_connect-0.28.1.data/scripts/snowpark-session,sha256=NMAHSonTo-nmOZSkQNlszUC0jLJ8QWEDUsUmMe2UAOw,190
+snowpark_connect-0.28.1.data/scripts/snowpark-submit,sha256=Zd98H9W_d0dIqMSkQLdHyW5G3myxF0t4c3vNBt2nD6A,12056
+snowpark_connect-0.28.1.dist-info/licenses/LICENSE-binary,sha256=fmBlX39HwTlBUyiKEznaLZGuxQy-7ndLLG_rTXjF02Y,22916
+snowpark_connect-0.28.1.dist-info/licenses/LICENSE.txt,sha256=Ff9cPv4xu0z7bnMTHzo4vDncOShsy33w4oJMA2xjn6c,11365
+snowpark_connect-0.28.1.dist-info/licenses/NOTICE-binary,sha256=elMF8brgGNJwOz8YdorzBF6-U8ZhR8F-77FfGkZng7U,57843
 spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spark/connect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spark/connect/envelope_pb2.py,sha256=7Gc6OUA3vaCuTCIKamb_Iiw7W9jPTcWNEv1im20eWHM,2726
 spark/connect/envelope_pb2.pyi,sha256=VXTJSPpcxzB_dWqVdvPY4KkPhJfh0WmkX7SNHWoLhx0,3358
-snowpark_connect-0.28.0.dist-info/METADATA,sha256=ZYd6i8wRgv9zajEKwzZ_v8jMcLYvPwN4yOGeLF6pj7g,1594
-snowpark_connect-0.28.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-snowpark_connect-0.28.0.dist-info/top_level.txt,sha256=ExnWqVpoTHRG99fu_AxXZVOz8c-De7nNu0yFCGylM8I,16
-snowpark_connect-0.28.0.dist-info/RECORD,,
+snowpark_connect-0.28.1.dist-info/METADATA,sha256=VYJ19DYnoBCToiaU__mf5hnm3hBrzN0bBv89QDVre8E,1594
+snowpark_connect-0.28.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+snowpark_connect-0.28.1.dist-info/top_level.txt,sha256=ExnWqVpoTHRG99fu_AxXZVOz8c-De7nNu0yFCGylM8I,16
+snowpark_connect-0.28.1.dist-info/RECORD,,