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

snowflake/snowpark_connect/relation/read/map_read_text.py

@@ -43,7 +43,12 @@ def read_text(
 ) -> snowpark.DataFrame:
     # TODO: handle stage name with double quotes
     files_paths = get_file_paths_from_stage(path, session)
-    stage_name = path.split("/")[0]
+    # Remove matching quotes from both ends of the path to get the stage name, if present.
+    if path and len(path) > 1 and path[0] == path[-1] and path[0] in ('"', "'"):
+        unquoted_path = path[1:-1]
+    else:
+        unquoted_path = path
+    stage_name = unquoted_path.split("/")[0]
     line_sep = options.get("lineSep") or "\n"
     column_name = (
         schema[0].name if schema is not None and len(schema.fields) > 0 else '"value"'

snowflake/snowpark_connect/relation/stage_locator.py

@@ -5,6 +5,7 @@
 import os
 
 from fsspec.core import url_to_fs
+from pyspark.errors.exceptions.base import AnalysisException
 from s3fs.core import S3FileSystem
 
 from snowflake import snowpark
@@ -33,37 +34,42 @@ def get_paths_from_stage(
 
     # TODO : What if GCP?
     # TODO: What if already stage path?
-    if get_cloud_from_url(paths[0]) == "azure":
-        rewrite_paths = []
-        for p in paths:
-            _, bucket_name, path = parse_azure_url(p)
-            rewrite_paths.append(f"{stage_name}/{path}")
-        paths = rewrite_paths
-    else:
-        filesystem, parsed_path = url_to_fs(paths[0])
-        if isinstance(filesystem, S3FileSystem):  # aws
-            # Remove bucket name from the path since the stage name will replace
-            # the bucket name in the path.
-            paths = [
-                f"{stage_name}/{'/'.join(url_to_fs(p)[1].split('/')[1:])}"
-                for p in paths
-            ]
-        else:  # local
-            # For local files, we need to preserve directory structure for partitioned data
-            # Instead of just using basename, we'll use the last few path components
-            new_paths = []
+    match get_cloud_from_url(paths[0]):
+        case "azure":
+            rewrite_paths = []
             for p in paths:
-                # Split the path and take the last 2-3 components to preserve structure
-                # but avoid very long paths
-                path_parts = p.split(os.sep)
-                if len(path_parts) >= 2:
-                    # Take last 2 components (e.g., "base_case/x=abc")
-                    relative_path = "/".join(path_parts[-2:])
-                else:
-                    # Single component, use basename
-                    relative_path = os.path.basename(p)
-                new_paths.append(f"{stage_name}/{relative_path}")
-            paths = new_paths
+                _, bucket_name, path = parse_azure_url(p)
+                rewrite_paths.append(f"{stage_name}/{path}")
+            paths = rewrite_paths
+        case "gcp":
+            raise AnalysisException(
+                "You must configure an integration for Google Cloud Storage to perform I/O operations rather than accessing the URL directly. Reference: https://docs.snowflake.com/en/user-guide/data-load-gcs-config"
+            )
+        case _:
+            filesystem, parsed_path = url_to_fs(paths[0])
+            if isinstance(filesystem, S3FileSystem):  # aws
+                # Remove bucket name from the path since the stage name will replace
+                # the bucket name in the path.
+                paths = [
+                    f"{stage_name}/{'/'.join(url_to_fs(p)[1].split('/')[1:])}"
+                    for p in paths
+                ]
+            else:  # local
+                # For local files, we need to preserve directory structure for partitioned data
+                # Instead of just using basename, we'll use the last few path components
+                new_paths = []
+                for p in paths:
+                    # Split the path and take the last 2-3 components to preserve structure
+                    # but avoid very long paths
+                    path_parts = p.split(os.sep)
+                    if len(path_parts) >= 2:
+                        # Take last 2 components (e.g., "base_case/x=abc")
+                        relative_path = "/".join(path_parts[-2:])
+                    else:
+                        # Single component, use basename
+                        relative_path = os.path.basename(p)
+                    new_paths.append(f"{stage_name}/{relative_path}")
+                paths = new_paths
 
     return paths
 
@@ -102,15 +108,21 @@ class StageLocator:
                 sql_query = f"CREATE OR REPLACE TEMP STAGE {stage_name[1:]} URL='azure://{account}.blob.core.windows.net/{bucket_name}'"
 
                 credential_session_key = (
-                    f"fs.azure.sas.{bucket_name}.{account}.blob.core.windows.net"
+                    f"fs.azure.sas.fixed.token.{account}.dfs.core.windows.net",
+                    f"fs.azure.sas.{bucket_name}.{account}.blob.core.windows.net",
                 )
                 credential = sessions_config.get(spark_session_id, None)
-                if (
-                    credential is not None
-                    and credential.get(credential_session_key) is not None
-                    and credential.get(credential_session_key).strip() != ""
-                ):
-                    sql_query += f" CREDENTIALS = (AZURE_SAS_TOKEN = '{credential.get(credential_session_key)}')"
+                sas_token = None
+                for session_key in credential_session_key:
+                    if (
+                        credential is not None
+                        and credential.get(session_key) is not None
+                        and credential.get(session_key).strip() != ""
+                    ):
+                        sas_token = credential.get(session_key)
+                        break
+                if sas_token is not None:
+                    sql_query += f" CREDENTIALS = (AZURE_SAS_TOKEN = '{sas_token}')"
 
                 logger.info(self.session.sql(sql_query).collect())
                 self.stages_for_azure[bucket_name] = stage_name
@@ -128,24 +140,44 @@ class StageLocator:
                     # but the rest of the time it's used, it does. We just drop it here.
                     sql_query = f"CREATE OR REPLACE TEMP STAGE {stage_name[1:]} URL='s3://{parsed_path.split('/')[0]}'"
                     credential = sessions_config.get(spark_session_id, None)
-                    if (
-                        credential is not None
-                        and credential.get("spark.hadoop.fs.s3a.access.key") is not None
-                        and credential.get("spark.hadoop.fs.s3a.secret.key") is not None
-                        and credential.get("spark.hadoop.fs.s3a.access.key").strip()
-                        != ""
-                        and credential.get("spark.hadoop.fs.s3a.secret.key").strip()
-                        != ""
-                    ):
-                        aws_keys = f" AWS_KEY_ID = '{credential.get('spark.hadoop.fs.s3a.access.key')}'"
-                        aws_keys += f" AWS_SECRET_KEY = '{credential.get('spark.hadoop.fs.s3a.secret.key')}'"
-                        if (
-                            credential.get("spark.hadoop.fs.s3a.session.token")
+                    if credential is not None:
+                        if (  # USE AWS KEYS to connect
+                            credential.get("spark.hadoop.fs.s3a.access.key") is not None
+                            and credential.get("spark.hadoop.fs.s3a.secret.key")
+                            is not None
+                            and credential.get("spark.hadoop.fs.s3a.access.key").strip()
+                            != ""
+                            and credential.get("spark.hadoop.fs.s3a.secret.key").strip()
+                            != ""
+                        ):
+                            aws_keys = f" AWS_KEY_ID = '{credential.get('spark.hadoop.fs.s3a.access.key')}'"
+                            aws_keys += f" AWS_SECRET_KEY = '{credential.get('spark.hadoop.fs.s3a.secret.key')}'"
+                            if (
+                                credential.get("spark.hadoop.fs.s3a.session.token")
+                                is not None
+                            ):
+                                aws_keys += f" AWS_TOKEN = '{credential.get('spark.hadoop.fs.s3a.session.token')}'"
+                            sql_query += f" CREDENTIALS = ({aws_keys})"
+                            sql_query += " ENCRYPTION = ( TYPE = 'AWS_SSE_S3' )"
+                        elif (  # USE AWS ROLE and KMS KEY to connect
+                            credential.get(
+                                "spark.hadoop.fs.s3a.server-side-encryption.key"
+                            )
+                            is not None
+                            and credential.get(
+                                "spark.hadoop.fs.s3a.server-side-encryption.key"
+                            ).strip()
+                            != ""
+                            and credential.get("spark.hadoop.fs.s3a.assumed.role.arn")
                             is not None
+                            and credential.get(
+                                "spark.hadoop.fs.s3a.assumed.role.arn"
+                            ).strip()
+                            != ""
                         ):
-                            aws_keys += f" AWS_TOKEN = '{credential.get('spark.hadoop.fs.s3a.session.token')}'"
-                        sql_query += f" CREDENTIALS = ({aws_keys})"
-                        sql_query += " ENCRYPTION = ( TYPE = 'AWS_SSE_S3' )"
+                            aws_role = f" AWS_ROLE = '{credential.get('spark.hadoop.fs.s3a.assumed.role.arn')}'"
+                            sql_query += f" CREDENTIALS = ({aws_role})"
+                            sql_query += f" ENCRYPTION = ( TYPE='AWS_SSE_KMS' KMS_KEY_ID = '{credential.get('spark.hadoop.fs.s3a.server-side-encryption.key')}' )"
 
                     logger.info(self.session.sql(sql_query).collect())
                     self.stages_for_aws[bucket_name] = stage_name

snowflake/snowpark_connect/relation/write/map_write.py

@@ -36,6 +36,8 @@ from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.io_utils import (
     convert_file_prefix_path,
     is_cloud_path,
+    is_supported_compression,
+    supported_compressions_for_format,
 )
 from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.relation.read.reader_config import CsvWriterConfig
@@ -179,7 +181,7 @@ def map_write(request: proto_base.ExecutePlanRequest):
                             f"Skipping REMOVE for root path {write_path} - too broad scope"
                         )
                     else:
-                        remove_command = f"REMOVE {write_path}/"
+                        remove_command = f"REMOVE '{write_path}/'"
                         session.sql(remove_command).collect()
                         logger.info(f"Successfully cleared directory: {write_path}")
                 except Exception as e:
@@ -208,6 +210,20 @@ def map_write(request: proto_base.ExecutePlanRequest):
             compression = write_op.options.get(
                 "compression", default_compression
             ).upper()
+
+            if not is_supported_compression(write_op.source, compression):
+                supported_compressions = supported_compressions_for_format(
+                    write_op.source
+                )
+                raise AnalysisException(
+                    f"Compression {compression} is not supported for {write_op.source} format. "
+                    + (
+                        f"Supported compressions: {sorted(supported_compressions)}"
+                        if supported_compressions
+                        else "No compression supported for this format."
+                    )
+                )
+
             parameters = {
                 "location": temp_file_prefix_on_stage,
                 "file_format_type": write_op.source
@@ -218,8 +234,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 +255,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.
@@ -410,9 +433,27 @@ def map_write(request: proto_base.ExecutePlanRequest):
                     )
         case _:
             snowpark_table_name = _spark_to_snowflake(write_op.table.table_name)
+            save_method = write_op.table.save_method
+
+            if (
+                write_op.source == "snowflake"
+                and write_op.table.save_method
+                == commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_UNSPECIFIED
+            ):
+                save_method = (
+                    commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_SAVE_AS_TABLE
+                )
+                if len(write_op.table.table_name) == 0:
+                    dbtable_name = write_op.options.get("dbtable", "")
+                    if len(dbtable_name) == 0:
+                        raise SnowparkConnectNotImplementedError(
+                            "Save command is not supported without a table name"
+                        )
+                    else:
+                        snowpark_table_name = _spark_to_snowflake(dbtable_name)
 
             if (
-                write_op.table.save_method
+                save_method
                 == commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_SAVE_AS_TABLE
             ):
                 match write_mode:
@@ -474,7 +515,7 @@ def map_write(request: proto_base.ExecutePlanRequest):
                             column_order=_column_order_for_write,
                         )
             elif (
-                write_op.table.save_method
+                save_method
                 == commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_INSERT_INTO
             ):
                 _validate_schema_and_get_writer(
@@ -486,7 +527,7 @@ def map_write(request: proto_base.ExecutePlanRequest):
                 )
             else:
                 raise SnowparkConnectNotImplementedError(
-                    f"Save command not supported: {write_op.table.save_method}"
+                    f"Save command not supported: {save_method}"
                 )
 
 
@@ -978,7 +1019,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/server.py

@@ -1161,23 +1161,28 @@ def get_session(url: Optional[str] = None, conf: SparkConf = None) -> SparkSessi
 
 
 def init_spark_session(conf: SparkConf = None) -> SparkSession:
-    try:
-        # For Notebooks on SPCS
-        from jdk4py import JAVA_HOME
-
-        os.environ["JAVA_HOME"] = str(JAVA_HOME)
-    except ModuleNotFoundError:
-        # For notebooks on Warehouse
-        os.environ["JAVA_HOME"] = os.environ["CONDA_PREFIX"]
-        os.environ["JAVA_LD_LIBRARY_PATH"] = os.path.join(
-            os.environ["CONDA_PREFIX"], "lib", "server"
-        )
-    logger.info("JAVA_HOME=%s", os.environ["JAVA_HOME"])
+    if os.environ.get("JAVA_HOME") is None:
+        try:
+            # For Notebooks on SPCS
+            from jdk4py import JAVA_HOME
+
+            os.environ["JAVA_HOME"] = str(JAVA_HOME)
+        except ModuleNotFoundError:
+            # For notebooks on Warehouse
+            conda_prefix = os.environ.get("CONDA_PREFIX")
+            if conda_prefix is not None:
+                os.environ["JAVA_HOME"] = conda_prefix
+                os.environ["JAVA_LD_LIBRARY_PATH"] = os.path.join(
+                    conda_prefix, "lib", "server"
+                )
+    logger.info("JAVA_HOME=%s", os.environ.get("JAVA_HOME", "Not defined"))
 
     os.environ["SPARK_LOCAL_HOSTNAME"] = "127.0.0.1"
     os.environ["SPARK_CONNECT_MODE_ENABLED"] = "1"
 
-    snowpark_session = snowpark.context.get_active_session()
+    from snowflake.snowpark_connect.utils.session import _get_current_snowpark_session
+
+    snowpark_session = _get_current_snowpark_session()
     start_session(snowpark_session=snowpark_session)
     return get_session(conf=conf)
 

snowflake/snowpark_connect/utils/context.py

@@ -30,9 +30,6 @@ _sql_aggregate_function_count = ContextVar[int](
     "_contains_aggregate_function", default=0
 )
 
-# Context for parsing map_partitions
-_map_partitions_stack = ContextVar[int]("_map_partitions_stack", default=0)
-
 # We have to generate our own plan IDs that are different from Spark's.
 # Spark plan IDs start at 0, so pick a "big enough" number to avoid overlaps.
 _STARTING_SQL_PLAN_ID = 0x80000000
@@ -70,6 +67,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",
@@ -210,16 +227,6 @@ def push_evaluating_join_condition(join_type, left_keys, right_keys):
         _is_evaluating_join_condition.set(prev)
 
 
-@contextmanager
-def push_map_partitions():
-    _map_partitions_stack.set(_map_partitions_stack.get() + 1)
-    yield
-
-
-def map_partitions_depth() -> int:
-    return _map_partitions_stack.get()
-
-
 @contextmanager
 def push_sql_scope():
     """
@@ -387,9 +394,9 @@ 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)
     _sql_aggregate_function_count.set(0)
     _sql_named_args.set({})
     _sql_pos_args.set({})

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/io_utils.py

@@ -3,10 +3,46 @@
 #
 import contextlib
 import functools
+import re
 
 from snowflake.snowpark import Session
+from snowflake.snowpark._internal.analyzer.analyzer_utils import (
+    create_file_format_statement,
+)
 from snowflake.snowpark_connect.utils.identifiers import FQN
 
+_MINUS_AT_THE_BEGINNING_REGEX = re.compile(r"^-")
+
+
+def cached_file_format(
+    session: Session, file_format: str, format_type_options: dict[str, str]
+) -> str:
+    """
+    Cache and return a file format name based on the given options.
+    """
+
+    function_name = _MINUS_AT_THE_BEGINNING_REGEX.sub(
+        "1", str(hash(frozenset(format_type_options.items())))
+    )
+    file_format_name = f"__SNOWPARK_CONNECT_FILE_FORMAT__{file_format}_{function_name}"
+    if file_format_name in session._file_formats:
+        return file_format_name
+
+    session.sql(
+        create_file_format_statement(
+            file_format_name,
+            file_format,
+            format_type_options,
+            temp=True,
+            if_not_exist=True,
+            use_scoped_temp_objects=False,
+            is_generated=True,
+        )
+    ).collect()
+
+    session._file_formats.add(file_format_name)
+    return file_format_name
+
 
 @functools.cache
 def file_format(

snowflake/snowpark_connect/utils/session.py

@@ -71,6 +71,9 @@ def configure_snowpark_session(session: snowpark.Session):
     init_builtin_udf_cache(session)
     init_external_udxf_cache(session)
 
+    # file format cache
+    session._file_formats = set()
+
     # Set experimental parameters (warnings globally suppressed)
     session.ast_enabled = False
     session.eliminate_numeric_sql_value_cast_enabled = False

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()