snowpark-connect 0.27.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

snowflake/snowpark_connect/utils/telemetry.py

@@ -11,10 +11,11 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Iterable
 from contextvars import ContextVar
+from dataclasses import dataclass
 from enum import Enum, unique
-from typing import Dict
 
 import google.protobuf.message
+import pyspark.sql.connect.proto.base_pb2 as proto_base
 
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.telemetry import (
@@ -26,6 +27,7 @@ from snowflake.connector.time_util import get_time_millis
 from snowflake.snowpark import Session
 from snowflake.snowpark._internal.utils import get_os_name, get_python_version
 from snowflake.snowpark.version import VERSION as snowpark_version
+from snowflake.snowpark_connect.error.error_codes import ErrorCodes
 from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.version import VERSION as sas_version
 
@@ -56,6 +58,7 @@ class TelemetryType(Enum):
 
 class EventType(Enum):
     SERVER_STARTED = "scos_server_started"
+    WARNING = "scos_warning"
 
 
 # global labels
@@ -88,6 +91,7 @@ RECORDED_CONFIG_KEYS = {
     "spark.sql.session.localRelationCacheThreshold",
     "spark.sql.mapKeyDedupPolicy",
     "snowpark.connect.sql.passthrough",
+    "snowpark.connect.cte.optimization_enabled",
     "snowpark.connect.iceberg.external_volume",
     "snowpark.connect.sql.identifiers.auto-uppercase",
     "snowpark.connect.udtf.compatibility_mode",
@@ -104,7 +108,16 @@ REDACTED_PLAN_SUFFIXES = [
 ]
 
 
-def _basic_telemetry_data() -> Dict:
+@dataclass
+class TelemetryMessage:
+    """Container for telemetry messages in the processing queue."""
+
+    message: dict
+    timestamp: int
+    is_warning: bool
+
+
+def _basic_telemetry_data() -> dict:
     return {
         **STATIC_TELEMETRY_DATA,
         TelemetryField.KEY_EVENT_ID.value: str(uuid.uuid4()),
@@ -121,9 +134,11 @@ def safe(func):
     def wrap(*args, **kwargs):
         try:
             func(*args, **kwargs)
-        except Exception:
-            # We don't really care if telemetry fails, just want to be safe for the user
-            logger.warning(f"Telemetry operation failed: {func}", exc_info=True)
+        except Exception as e:
+            # report failed operation to telemetry
+            telemetry.send_warning_msg(
+                f"Telemetry operation {func} failed due to exception", e
+            )
 
     return wrap
 
@@ -289,10 +304,7 @@ class Telemetry:
 
         self._request_summary.set(summary)
 
-        if hasattr(request, "plan"):
-            summary["query_plan"] = _protobuf_to_json_with_redaction(
-                request.plan, REDACTED_PLAN_SUFFIXES
-            )
+        _set_query_plan(request, summary)
 
     def _not_in_request(self):
         # we don't want to add things to the summary if it's not initialized
@@ -335,6 +347,11 @@ class Telemetry:
         summary["error_message"] = str(e)
         summary["error_type"] = type(e).__name__
 
+        if not hasattr(e, "custom_error_code") or (e.custom_error_code is None):
+            summary["error_code"] = ErrorCodes.INTERNAL_ERROR
+        else:
+            summary["error_code"] = e.custom_error_code
+
         error_location = _error_location(e)
         if error_location:
             summary["error_location"] = error_location
@@ -426,6 +443,63 @@ class Telemetry:
 
         summary["internal_queries"] += 1
 
+    @safe
+    def report_describe_query_cache_lookup(self):
+        """Report a describe query cache lookup."""
+        if self._not_in_request():
+            return
+
+        summary = self._request_summary.get()
+
+        if "describe_cache_lookups" not in summary:
+            summary["describe_cache_lookups"] = 0
+
+        summary["describe_cache_lookups"] += 1
+
+    @safe
+    def report_describe_query_cache_hit(self):
+        """Report a describe query cache hit."""
+        if self._not_in_request():
+            return
+
+        summary = self._request_summary.get()
+
+        if "describe_cache_hits" not in summary:
+            summary["describe_cache_hits"] = 0
+
+        summary["describe_cache_hits"] += 1
+
+    @safe
+    def report_describe_query_cache_expired(self, expired_by: float):
+        """Report a describe query cache hit."""
+        if self._not_in_request():
+            return
+
+        summary = self._request_summary.get()
+
+        if "describe_cache_expired" not in summary:
+            summary["describe_cache_expired"] = 0
+
+        summary["describe_cache_expired"] += 1
+
+        if "describe_cache_expired_by" not in summary:
+            summary["describe_cache_expired_by"] = []
+
+        summary["describe_cache_expired_by"].append(expired_by)
+
+    @safe
+    def report_describe_query_cache_clear(self):
+        """Report a describe query cache clear."""
+        if self._not_in_request():
+            return
+
+        summary = self._request_summary.get()
+
+        if "describe_cache_cleared" not in summary:
+            summary["describe_cache_cleared"] = 0
+
+        summary["describe_cache_cleared"] += 1
+
     @safe
     def report_udf_usage(self, udf_name: str):
         if self._not_in_request():
@@ -472,8 +546,8 @@ class Telemetry:
     @safe
     def send_request_summary_telemetry(self):
         if self._not_in_request():
-            logger.warning(
-                "Truing to send request summary telemetry without initializing it"
+            self.send_warning_msg(
+                "Trying to send request summary telemetry without initializing it"
             )
             return
 
@@ -485,14 +559,56 @@ class Telemetry:
         }
         self._send(message)
 
-    def _send(self, msg: Dict) -> None:
+    def send_warning_msg(self, msg: str, e: Exception = None) -> None:
+        # using this within @safe decorator may result in recursive loop
+        try:
+            message = self._build_warning_message(msg, e)
+            if not message:
+                return
+
+            self._send(message, is_warning=True)
+        except Exception:
+            # if there's an exception here, there's nothing we can really do about it
+            pass
+
+    def _build_warning_message(self, warning_msg: str, e: Exception = None) -> dict:
+        try:
+            data = {"warning_message": warning_msg}
+            if e is not None:
+                data["exception"] = repr(e)
+
+            # add session and operation id if available
+            spark_session_id = self._request_summary.get().get("spark_session_id", None)
+            if spark_session_id is not None:
+                data["spark_session_id"] = spark_session_id
+
+            spark_operation_id = self._request_summary.get().get(
+                "spark_operation_id", None
+            )
+            if spark_operation_id is not None:
+                data["spark_operation_id"] = spark_operation_id
+
+            message = {
+                **_basic_telemetry_data(),
+                TelemetryField.KEY_TYPE.value: TelemetryType.TYPE_EVENT.value,
+                TelemetryType.EVENT_TYPE.value: EventType.WARNING.value,
+                TelemetryField.KEY_DATA.value: data,
+            }
+            return message
+        except Exception:
+            return {}
+
+    def _send(self, msg: dict, is_warning: bool = False) -> None:
         """Queue a telemetry message for asynchronous processing."""
         if not self._is_enabled:
             return
 
         timestamp = get_time_millis()
         try:
-            self._message_queue.put_nowait((msg, timestamp))
+            telemetry_msg = TelemetryMessage(
+                message=msg, timestamp=timestamp, is_warning=is_warning
+            )
+            self._message_queue.put_nowait(telemetry_msg)
         except queue.Full:
             # If queue is full, drop the message to avoid blocking
             logger.warning("Telemetry queue is full, dropping message")
@@ -510,13 +626,16 @@ class Telemetry:
         while True:
             try:
                 # block to allow the GIL to switch threads
-                message, timestamp = self._message_queue.get()
-                if timestamp is None and message is None:
-                    # shutdown
+                telemetry_msg = self._message_queue.get()
+                if telemetry_msg is None:
+                    # shutdown signal
                     break
-                self._sink.add_telemetry_data(message, timestamp)
-            except Exception:
-                logger.warning("Failed to add telemetry message to sink", exc_info=True)
+                self._sink.add_telemetry_data(
+                    telemetry_msg.message, telemetry_msg.timestamp
+                )
+            except Exception as e:
+                if not telemetry_msg.is_warning:
+                    self.send_warning_msg("Failed to add telemetry message to sink", e)
             finally:
                 self._message_queue.task_done()
 
@@ -529,7 +648,7 @@ class Telemetry:
             return
 
         try:
-            self._message_queue.put_nowait((None, None))
+            self._message_queue.put_nowait(None)
             # Wait for worker thread to finish
             self._worker_thread.join(timeout=3.0)
         except Exception:
@@ -538,7 +657,7 @@ class Telemetry:
             )
 
 
-def _error_location(e: Exception) -> Dict | None:
+def _error_location(e: Exception) -> dict | None:
     """
     Inspect the exception traceback and extract the file name, line number, and function name
     from the last frame (the one that raised the exception).
@@ -619,7 +738,7 @@ def _protobuf_to_json_with_redaction(
         """Recursively convert protobuf message to dict"""
 
         if not isinstance(msg, google.protobuf.message.Message):
-            logger.warning("Expected a protobuf message, got: %s", type(msg))
+            telemetry.send_warning_msg(f"Expected a protobuf message, got: {type(msg)}")
             return {}
 
         result = {}
@@ -644,6 +763,28 @@ def _protobuf_to_json_with_redaction(
     )
 
 
+def _set_query_plan(request: google.protobuf.message.Message, summary: dict) -> None:
+    if isinstance(request, proto_base.ExecutePlanRequest):
+        # ExecutePlanRequest has plan at top level
+        if hasattr(request, "plan"):
+            summary["query_plan"] = (
+                _protobuf_to_json_with_redaction(request.plan, REDACTED_PLAN_SUFFIXES),
+            )
+
+    elif isinstance(request, proto_base.AnalyzePlanRequest):
+        # AnalyzePlanRequest has plan under oneof analyze
+        analyze_type = request.WhichOneof("analyze")
+        if not analyze_type:
+            return
+
+        summary["analyze_type"] = analyze_type
+        analyze_field = getattr(request, analyze_type)
+        if hasattr(analyze_field, "plan"):
+            summary["query_plan"] = _protobuf_to_json_with_redaction(
+                analyze_field.plan, REDACTED_PLAN_SUFFIXES
+            )
+
+
 # global telemetry client
 telemetry = Telemetry(is_enabled="SNOWPARK_CONNECT_DISABLE_TELEMETRY" not in os.environ)
 

snowflake/snowpark_connect/utils/temporary_view_cache.py

@@ -0,0 +1,67 @@
+#
+# 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.error.error_codes import ErrorCodes
+from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
+from snowflake.snowpark_connect.utils.concurrent import SynchronizedDict
+from snowflake.snowpark_connect.utils.context import get_spark_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_spark_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:
+                exception = AnalysisException(
+                    f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{name}` because it already exists."
+                )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+                raise exception
+
+    _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_spark_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_spark_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_spark_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/temporary_view_helper.py

@@ -0,0 +1,334 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+import re
+import uuid
+from collections import Counter
+from typing import Optional, Tuple
+
+from pyspark.errors import AnalysisException
+from pyspark.errors.exceptions.base import TempTableAlreadyExistsException
+
+from snowflake.snowpark import DataFrame, Session
+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, ColumnNames
+from snowflake.snowpark_connect.config import (
+    global_config,
+    sessions_config,
+    should_create_temporary_view_in_snowflake,
+)
+from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
+from snowflake.snowpark_connect.utils.concurrent import SynchronizedDict
+from snowflake.snowpark_connect.utils.context import get_spark_session_id
+from snowflake.snowpark_connect.utils.identifiers import (
+    spark_to_sf_single_id,
+    spark_to_sf_single_id_with_unquoting,
+)
+
+_INTERNAL_VIEW_PREFIX = "__SC_RENAMED_V_"
+
+_CREATE_VIEW_PATTERN = re.compile(r"create\s+or\s+replace\s+view", re.IGNORECASE)
+
+_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_spark_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 TempTableAlreadyExistsException(
+                    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_spark_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_spark_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_spark_session_id()
+    ]
+
+
+def _normalize(name: str) -> str:
+    return name if global_config.spark_sql_caseSensitive else name.lower()
+
+
+def assert_snowflake_view_does_not_exist_in_cache(name: str, replace: bool):
+    temp_view = get_temp_view(name)
+    if temp_view is not None and not replace:
+        raise AnalysisException(
+            f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{name}` because it already exists."
+        )
+
+
+def assert_cached_view_does_not_exist_in_snowflake(
+    snowflake_view_name: list[str], replace: bool
+):
+    if len(snowflake_view_name) == 1:
+        name = unquote_if_quoted(snowflake_view_name[0])
+        sql_statement = f"SHOW VIEWS LIKE '{name}'"
+    else:
+        name = unquote_if_quoted(snowflake_view_name[1])
+        sql_statement = f"SHOW VIEWS LIKE '{name}' IN SCHEMA {snowflake_view_name[0]}"
+    if (
+        not replace
+        and len(Session.get_active_session().sql(sql_statement).collect()) > 0
+    ):
+        raise AnalysisException(
+            f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{name}` because it already exists."
+        )
+
+
+def create_temporary_view_from_dataframe(
+    input_df_container: DataFrameContainer,
+    request_view_name: str,
+    is_global: bool,
+    replace: bool,
+) -> None:
+    input_df = input_df_container.dataframe
+
+    if is_global:
+        view_name = [global_config.spark_sql_globalTempDatabase, request_view_name]
+    else:
+        view_name = [request_view_name]
+    case_sensitive_view_name = ".".join(
+        [spark_to_sf_single_id_with_unquoting(part) for part in view_name]
+    )
+    snowflake_view_name = [
+        spark_to_sf_single_id_with_unquoting(part, True) for part in view_name
+    ]
+
+    if should_create_temporary_view_in_snowflake():
+        _create_snowflake_temporary_view(
+            input_df_container, snowflake_view_name, case_sensitive_view_name, replace
+        )
+    else:
+        store_temporary_view_as_dataframe(
+            input_df,
+            input_df_container.column_map,
+            input_df_container.column_map.get_spark_columns(),
+            input_df_container.column_map.get_snowpark_columns(),
+            case_sensitive_view_name,
+            snowflake_view_name,
+            replace,
+        )
+
+
+def _create_snowflake_temporary_view(
+    input_df_container: DataFrameContainer,
+    snowflake_view_name: list[str],
+    stored_view_name: str,
+    replace: bool,
+):
+    column_map = input_df_container.column_map
+    input_df = input_df_container.dataframe
+
+    session_config = sessions_config[get_spark_session_id()]
+    duplicate_column_names_handling_mode = session_config[
+        "snowpark.connect.views.duplicate_column_names_handling_mode"
+    ]
+
+    # rename columns to match spark names
+    if duplicate_column_names_handling_mode == "rename":
+        # deduplicate column names by appending _DEDUP_1, _DEDUP_2, etc.
+        rename_map = _create_column_rename_map(column_map.columns, True)
+        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)
+        if len(duplicated_columns) > 0:
+            input_df = input_df.drop(*duplicated_columns)
+        input_df = input_df.rename(rename_map)
+    else:
+        # rename columns without deduplication
+        rename_map = _create_column_rename_map(column_map.columns, False)
+        input_df = input_df.rename(rename_map)
+
+    try:
+        create_snowflake_temporary_view(
+            input_df, snowflake_view_name, stored_view_name, replace
+        )
+    except SnowparkSQLException as exc:
+        if _is_error_caused_by_view_referencing_itself(exc) and replace:
+            # This error is caused by statement with self reference like `CREATE VIEW A AS SELECT X FROM A`.
+            _create_chained_view(input_df, snowflake_view_name)
+        else:
+            raise
+
+
+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_sf_single_id(col.spark_name, is_column=True)
+            for col in columns
+        }
+
+    column_counts = Counter()
+    not_renamed_cols = []
+    renamed_cols = []
+
+    for col in columns:
+        new_column_name = col.spark_name
+        normalized_name = new_column_name.lower()
+        column_counts[normalized_name] += 1
+
+        if column_counts[normalized_name] > 1:
+            new_column_name = (
+                f"{new_column_name}_DEDUP_{column_counts[normalized_name] - 1}"
+            )
+            renamed_cols.append(ColumnNames(new_column_name, col.snowpark_name, []))
+        else:
+            not_renamed_cols.append(ColumnNames(new_column_name, col.snowpark_name, []))
+
+    if len(renamed_cols) == 0:
+        return {
+            col.snowpark_name: spark_to_sf_single_id(col.spark_name, is_column=True)
+            for col in not_renamed_cols
+        }
+
+    # we need to make sure that we don't have duplicated names after renaming
+    # columns that were not renamed in this iteration should have priority over renamed duplicates
+    return _create_column_rename_map(not_renamed_cols + renamed_cols, True)
+
+
+def _find_duplicated_columns(
+    columns: list[ColumnNames],
+) -> (list[str], list[ColumnNames]):
+    duplicates = []
+    remaining_columns = []
+    seen = set()
+    for col in columns:
+        if col.spark_name in seen:
+            duplicates.append(col.snowpark_name)
+        else:
+            seen.add(col.spark_name)
+            remaining_columns.append(col)
+    return duplicates, remaining_columns
+
+
+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: list[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()
+
+
+def store_temporary_view_as_dataframe(
+    input_df: DataFrame,
+    parent_column_map: ColumnNameMap,
+    spark_columns: list[str],
+    snowpark_columns: list[str],
+    view_name: str,
+    snowflake_view_name: list[str],
+    replace: bool,
+):
+    assert_cached_view_does_not_exist_in_snowflake(snowflake_view_name, replace)
+    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=parent_column_map,
+        cached_schema_getter=lambda: schema,
+    )
+
+    if replace:
+        try:
+            Session.get_active_session().sql(
+                "DROP VIEW IF EXISTS " + ".".join(snowflake_view_name)
+            ).collect()
+        except SnowparkSQLException as e:
+            # Spark allows for both table and temporary view to exist with the same name.
+            # Snowflake throws exception if we try to drop the view with doesn't exist but a table with the same name exists.
+            if (
+                "SQL compilation error: Object found is of type 'TABLE', not specified type 'VIEW'"
+                not in str(e)
+            ):
+                raise
+
+    register_temp_view(view_name, input_df_container, replace)
+
+
+def create_snowflake_temporary_view(
+    input_df: DataFrame,
+    snowflake_view_name: list[str],
+    stored_view_name: str,
+    replace: bool,
+    comment: Optional[str] = None,
+) -> None:
+    assert_snowflake_view_does_not_exist_in_cache(stored_view_name, replace)
+    if replace:
+        unregister_temp_view(stored_view_name)
+        input_df.create_or_replace_temp_view(snowflake_view_name, comment=comment)
+    else:
+        input_df.create_temp_view(snowflake_view_name, comment=comment)