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

snowflake/snowpark_connect/error/error_utils.py

@@ -12,11 +12,13 @@ https://github.com/apache/spark/blob/master/common/utils/src/main/resources/erro
 import json
 import pathlib
 import re
+import threading
 import traceback
 
 import jpype
 from google.protobuf import any_pb2
 from google.rpc import code_pb2, error_details_pb2, status_pb2
+from pyspark.errors import TempTableAlreadyExistsException
 from pyspark.errors.error_classes import ERROR_CLASSES_MAP
 from pyspark.errors.exceptions.base import (
     AnalysisException,
@@ -35,9 +37,12 @@ from snowflake.core.exceptions import NotFoundError
 
 from snowflake.connector.errors import ProgrammingError
 from snowflake.snowpark.exceptions import SnowparkClientException, SnowparkSQLException
-from snowflake.snowpark_connect.config import global_config
+from snowflake.snowpark_connect.error.error_codes import ErrorCodes
 from snowflake.snowpark_connect.error.error_mapping import ERROR_MAPPINGS_JSON
 
+# Thread-local storage for custom error codes when we can't attach them directly to exceptions
+_thread_local = threading.local()
+
 # The JSON string in error_mapping.py is a copy of https://github.com/apache/spark/blob/master/common/utils/src/main/resources/error/error-conditions.json.
 # The file doesn't have to be synced with spark latest main. Just update it when required.
 current_dir = pathlib.Path(__file__).parent.resolve()
@@ -54,8 +59,11 @@ SPARK_PYTHON_TO_JAVA_EXCEPTION = {
     SparkConnectGrpcException: "pyspark.errors.exceptions.connect.SparkConnectGrpcException",
     PythonException: "org.apache.spark.api.python.PythonException",
     UnsupportedOperationException: "java.lang.UnsupportedOperationException",
+    TempTableAlreadyExistsException: "org.apache.spark.sql.catalyst.analysis.TempTableAlreadyExistsException",
 }
 
+TABLE_OR_VIEW_NOT_FOUND_ERROR_CLASS = "TABLE_OR_VIEW_NOT_FOUND"
+
 WINDOW_FUNCTION_ANALYSIS_EXCEPTION_SQL_ERROR_CODE = {1005, 2303}
 ANALYSIS_EXCEPTION_SQL_ERROR_CODE = {
     904,
@@ -79,6 +87,23 @@ invalid_bit_pattern = re.compile(
     r"Invalid bit position: \d+ exceeds the bit (?:upper|lower) limit",
     re.IGNORECASE,
 )
+CREATE_SCHEMA_PATTERN = re.compile(r"create\s+schema", re.IGNORECASE)
+CREATE_TABLE_PATTERN = re.compile(r"create\s+table", re.IGNORECASE)
+
+
+def attach_custom_error_code(exception: Exception, custom_error_code: int) -> Exception:
+    """
+    Attach a custom error code to any exception instance.
+    This allows us to add custom error codes to existing PySpark exceptions.
+    """
+    if not hasattr(exception, "custom_error_code"):
+        try:
+            exception.custom_error_code = custom_error_code
+        except (AttributeError, TypeError):
+            # Some exception types (like Java exceptions) don't allow setting custom attributes
+            # Store the error code in thread-local storage for later retrieval
+            _thread_local.pending_error_code = custom_error_code
+    return exception
 
 
 def contains_udtf_select(sql_string):
@@ -100,20 +125,29 @@ def _get_converted_known_sql_or_custom_exception(
 
     # custom exception
     if "[snowpark_connect::invalid_array_index]" in msg:
-        return ArrayIndexOutOfBoundsException(
+        exception = ArrayIndexOutOfBoundsException(
             message='The index <indexValue> is out of bounds. The array has <arraySize> elements. Use the SQL function `get()` to tolerate accessing element at invalid index and return NULL instead. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error.'
         )
+        attach_custom_error_code(exception, ErrorCodes.ARRAY_INDEX_OUT_OF_BOUNDS)
+        return exception
     if "[snowpark_connect::invalid_index_of_zero]" in msg:
-        return SparkRuntimeException(
+        exception = SparkRuntimeException(
             message="[INVALID_INDEX_OF_ZERO] The index 0 is invalid. An index shall be either < 0 or > 0 (the first element has index 1)."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        return exception
     if "[snowpark_connect::invalid_index_of_zero_in_slice]" in msg:
-        return SparkRuntimeException(
+        exception = SparkRuntimeException(
             message="Unexpected value for start in function slice: SQL array indices start at 1."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        return exception
+
     invalid_bit = invalid_bit_pattern.search(msg)
     if invalid_bit:
-        return IllegalArgumentException(message=invalid_bit.group(0))
+        exception = IllegalArgumentException(message=invalid_bit.group(0))
+        attach_custom_error_code(exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT)
+        return exception
     match = snowpark_connect_exception_pattern.search(
         ex.message if hasattr(ex, "message") else str(ex)
     )
@@ -125,71 +159,136 @@ def _get_converted_known_sql_or_custom_exception(
             if class_name
             else SparkConnectGrpcException
         )
-        return exception_class(message=message)
+        exception = exception_class(message=message)
+        attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+        return exception
 
     if "select with no columns" in msg and contains_udtf_select(query):
         # We try our best to detect if the SQL string contains a UDTF call and the output schema is empty.
-        return PythonException(message=f"[UDTF_RETURN_SCHEMA_MISMATCH] {ex.message}")
+        exception = PythonException(
+            message=f"[UDTF_RETURN_SCHEMA_MISMATCH] {ex.message}"
+        )
+        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+        return exception
 
     # known sql exception
     if ex.sql_error_code not in (100038, 100037, 100035, 100357):
         return None
 
     if "(22018): numeric value" in msg:
-        return NumberFormatException(
+        exception = NumberFormatException(
             message='[CAST_INVALID_INPUT] Correct the value as per the syntax, or change its target type. Use `try_cast` to tolerate malformed input and return NULL instead. If necessary setting "spark.sql.ansi.enabled" to "false" may bypass this error.'
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+        return exception
     if "(22018): boolean value" in msg:
-        return SparkRuntimeException(
+        exception = SparkRuntimeException(
             message='[CAST_INVALID_INPUT] Correct the value as per the syntax, or change its target type. Use `try_cast` to tolerate malformed input and return NULL instead. If necessary setting "spark.sql.ansi.enabled" to "false" may bypass this error.'
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+        return exception
     if "(22007): timestamp" in msg:
-        return AnalysisException(
+        exception = AnalysisException(
             "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Data type mismatch"
         )
+        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+        return exception
 
     if getattr(ex, "sql_error_code", None) == 100357:
         if re.search(init_multi_args_exception_pattern, msg):
-            return PythonException(
+            exception = PythonException(
                 message=f"[UDTF_EXEC_ERROR] User defined table function encountered an error in the init method {ex.message}"
             )
+            attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+            return exception
         if re.search(terminate_multi_args_exception_pattern, msg):
-            return PythonException(
+            exception = PythonException(
                 message=f"[UDTF_EXEC_ERROR] User defined table function encountered an error in the terminate method: {ex.message}"
             )
+            attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+            return exception
 
         if "failed to split string, provided pattern:" in msg:
-            return IllegalArgumentException(
+            exception = IllegalArgumentException(
                 message=f"Failed to split string using provided pattern. {ex.message}"
             )
+            attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+            return exception
 
         if "100357" in msg and "wrong tuple size for returned value" in msg:
-            return PythonException(
+            exception = PythonException(
                 message=f"[UDTF_RETURN_SCHEMA_MISMATCH] The number of columns in the result does not match the specified schema. {ex.message}"
             )
+            attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+            return exception
 
         if "100357 (p0000): python interpreter error:" in msg:
             if "in eval" in msg:
-                return PythonException(
+                exception = PythonException(
                     message=f"[UDTF_EXEC_ERROR] User defined table function encountered an error in the 'eval' method: error. {ex.message}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                return exception
 
             if "in terminate" in msg:
-                return PythonException(
+                exception = PythonException(
                     message=f"[UDTF_EXEC_ERROR] User defined table function encountered an error in the 'terminate' method: terminate error. {ex.message}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                return exception
 
             if "object is not iterable" in msg and contains_udtf_select(query):
-                return PythonException(
+                exception = PythonException(
                     message=f"[UDTF_RETURN_NOT_ITERABLE] {ex.message}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                return exception
 
-            return PythonException(message=f"{ex.message}")
+            exception = PythonException(message=f"{ex.message}")
+            attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+            return exception
 
     return None
 
 
+def _sanitize_custom_error_message(msg):
+    if "[snowpark_connect::unsupported_operation]" in msg:
+        return (
+            msg.replace("[snowpark_connect::unsupported_operation] ", ""),
+            ErrorCodes.UNSUPPORTED_OPERATION,
+        )
+    if "[snowpark_connect::internal_error]" in msg:
+        return (
+            msg.replace("[snowpark_connect::internal_error] ", ""),
+            ErrorCodes.INTERNAL_ERROR,
+        )
+    if "[snowpark_connect::invalid_operation]" in msg:
+        return (
+            msg.replace("[snowpark_connect::invalid_operation] ", ""),
+            ErrorCodes.INVALID_OPERATION,
+        )
+    if "[snowpark_connect::type_mismatch]" in msg:
+        return (
+            msg.replace("[snowpark_connect::type_mismatch] ", ""),
+            ErrorCodes.TYPE_MISMATCH,
+        )
+    if "[snowpark_connect::invalid_input]" in msg:
+        return (
+            msg.replace("[snowpark_connect::invalid_input] ", ""),
+            ErrorCodes.INVALID_INPUT,
+        )
+    if "[snowpark_connect::unsupported_type]" in msg:
+        return (
+            msg.replace("[snowpark_connect::unsupported_type] ", ""),
+            ErrorCodes.UNSUPPORTED_TYPE,
+        )
+    return msg, None
+
+
 def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
+    # Lazy import to avoid circular dependency
+    from snowflake.snowpark_connect.config import global_config
+
     include_stack_trace = (
         global_config.get("spark.sql.pyspark.jvmStacktrace.enabled")
         if hasattr(global_config, "spark.sql.pyspark.jvmStacktrace.enabled")
@@ -203,6 +302,16 @@ def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
         match ex:
             case SnowparkSQLException():
                 if ex.sql_error_code in ANALYSIS_EXCEPTION_SQL_ERROR_CODE:
+                    # Creation of schema that already exists
+                    if ex.sql_error_code == 2002 and "already exists" in str(ex):
+                        if CREATE_SCHEMA_PATTERN.search(ex.query):
+                            spark_java_classes.append(
+                                "org.apache.spark.sql.catalyst.analysis.NamespaceAlreadyExistsException"
+                            )
+                        elif CREATE_TABLE_PATTERN.search(ex.query):
+                            spark_java_classes.append(
+                                "org.apache.spark.sql.catalyst.analysis.TableAlreadyExistsException"
+                            )
                     # Data type mismatch, invalid window function
                     spark_java_classes.append("org.apache.spark.sql.AnalysisException")
                 elif ex.sql_error_code == 100051:
@@ -211,6 +320,7 @@ def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
                         error_class="DIVIDE_BY_ZERO",
                         message_parameters={"config": '"spark.sql.ansi.enabled"'},
                     )
+                    attach_custom_error_code(ex, ErrorCodes.DIVISION_BY_ZERO)
                 elif ex.sql_error_code in (100096, 100040):
                     # Spark seems to want the Java base class instead of org.apache.spark.sql.SparkDateTimeException
                     # which is what should really be thrown
@@ -221,6 +331,9 @@ def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
                     ex = spark_ex
                     spark_java_classes.append(SPARK_PYTHON_TO_JAVA_EXCEPTION[type(ex)])
                 elif ex.sql_error_code == 2043:
+                    spark_java_classes.append(
+                        "org.apache.spark.sql.catalyst.analysis.NoSuchDatabaseException"
+                    )
                     spark_java_classes.append("org.apache.spark.sql.AnalysisException")
                     message = f"does_not_exist: {str(ex)}"
                 else:
@@ -252,13 +365,23 @@ def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
         )
     elif isinstance(ex, PySparkException):
         # pyspark exceptions thrown in sas layer
+
+        error_derived_java_class = []
+        if ex.error_class == TABLE_OR_VIEW_NOT_FOUND_ERROR_CLASS:
+            error_derived_java_class.append(
+                "org.apache.spark.sql.catalyst.analysis.NoSuchTableException"
+            )
+
         classes = type(ex).__mro__
         spark_java_classes = [
             SPARK_PYTHON_TO_JAVA_EXCEPTION[clazz]
             for clazz in classes
             if clazz in SPARK_PYTHON_TO_JAVA_EXCEPTION
         ]
-        metadata = {"classes": json.dumps(spark_java_classes)}
+
+        metadata = {
+            "classes": json.dumps(error_derived_java_class + spark_java_classes)
+        }
         if include_stack_trace:
             metadata["stackTrace"] = "".join(
                 traceback.TracebackException.from_exception(ex).format()
@@ -299,14 +422,40 @@ def build_grpc_error_response(ex: Exception) -> status_pb2.Status:
             domain="snowflake.sas",
         )
 
-    detail = any_pb2.Any()
-    detail.Pack(error_info)
-
     if message is None:
         message = str(ex)
 
+    custom_error_code = None
+
+    # attach error code using visa exception message
+    message, custom_error_code_from_msg = _sanitize_custom_error_message(message)
+
+    # Check if exception already has a custom error code, if not add INTERNAL_ERROR as default
+    if not hasattr(ex, "custom_error_code") or ex.custom_error_code is None:
+        attach_custom_error_code(
+            ex,
+            ErrorCodes.INTERNAL_ERROR
+            if custom_error_code_from_msg is None
+            else custom_error_code_from_msg,
+        )
+
+    # Get the custom error code from the exception or thread-local storage
+    custom_error_code = getattr(ex, "custom_error_code", None) or getattr(
+        _thread_local, "pending_error_code", None
+    )
+
+    # Clear thread-local storage after retrieving the error code
+    if hasattr(_thread_local, "pending_error_code"):
+        delattr(_thread_local, "pending_error_code")
+
+    separator = "==========================================="
+    error_code_added_message = f"\n{separator}\nSNOWPARK CONNECT ERROR CODE: {custom_error_code}\n{separator}\n{message}"
+
+    detail = any_pb2.Any()
+    detail.Pack(error_info)
+
     rich_status = status_pb2.Status(
-        code=code_pb2.INTERNAL, message=message, details=[detail]
+        code=code_pb2.INTERNAL, message=error_code_added_message, details=[detail]
     )
     return rich_status
 

snowflake/snowpark_connect/error/exceptions.py

@@ -2,27 +2,36 @@
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
 
+from snowflake.snowpark_connect.error.error_codes import ErrorCodes
+
 
 class SnowparkConnectException(Exception):
     """Parent class to all SnowparkConnect related exceptions."""
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args, custom_error_code=None, **kwargs) -> None:
         super().__init__(*args, **kwargs)
+        self.custom_error_code = custom_error_code
 
 
 class MissingDatabase(SnowparkConnectException):
-    def __init__(self) -> None:
+    def __init__(self, custom_error_code=None) -> None:
         super().__init__(
             "No default database found in session",
+            custom_error_code=custom_error_code or ErrorCodes.MISSING_DATABASE,
         )
 
 
 class MissingSchema(SnowparkConnectException):
-    def __init__(self) -> None:
+    def __init__(self, custom_error_code=None) -> None:
         super().__init__(
             "No default schema found in session",
+            custom_error_code=custom_error_code or ErrorCodes.MISSING_SCHEMA,
         )
 
 
 class MaxRetryExceeded(SnowparkConnectException):
-    ...
+    def __init__(
+        self,
+        message="Maximum retry attempts exceeded",
+    ) -> None:
+        super().__init__(message)

snowflake/snowpark_connect/execute_plan/map_execution_command.py

@@ -1,90 +1,29 @@
 #
 # 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_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.error.error_codes import ErrorCodes
+from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
 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
 from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.relation.map_sql import map_sql_to_pandas_df
-from snowflake.snowpark_connect.relation.write.map_write import map_write, map_write_v2
-from snowflake.snowpark_connect.utils.context import get_session_id
-from snowflake.snowpark_connect.utils.identifiers import (
-    spark_to_sf_single_id,
-    spark_to_sf_single_id_with_unquoting,
+from snowflake.snowpark_connect.relation.read.metadata_utils import (
+    without_internal_columns,
 )
+from snowflake.snowpark_connect.relation.write.map_write import map_write, map_write_v2
 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)
-
-
-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
+from snowflake.snowpark_connect.utils.temporary_view_helper import (
+    create_temporary_view_from_dataframe,
+)
 
 
 def map_execution_command(
@@ -94,56 +33,10 @@ def map_execution_command(
     match request.plan.command.WhichOneof("command_type"):
         case "create_dataframe_view":
             req = request.plan.command.create_dataframe_view
-            input_df_container = map_relation(req.input)
-            input_df = input_df_container.dataframe
-            column_map = input_df_container.column_map
-
-            session_config = sessions_config[get_session_id()]
-            duplicate_column_names_handling_mode = session_config[
-                "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.
-                input_df = input_df.rename(
-                    _create_column_rename_map(column_map.columns, True)
-                )
-            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
-                )
-                if len(duplicated_columns) > 0:
-                    input_df = input_df.drop(*duplicated_columns)
-                input_df = input_df.rename(
-                    _create_column_rename_map(remaining_columns, False)
-                )
-            else:
-                # rename columns without deduplication
-                input_df = input_df.rename(
-                    _create_column_rename_map(column_map.columns, False)
-                )
-
-            if req.is_global:
-                view_name = [global_config.spark_sql_globalTempDatabase, req.name]
-            else:
-                view_name = [req.name]
-            view_name = [
-                spark_to_sf_single_id_with_unquoting(part) for part in 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)
+            input_df_container = without_internal_columns(map_relation(req.input))
+            create_temporary_view_from_dataframe(
+                input_df_container, req.name, req.is_global, req.replace
+            )
         case "write_stream_operation_start":
             match request.plan.command.write_stream_operation_start.format:
                 case "console":
@@ -204,46 +97,8 @@ def map_execution_command(
             map_udtf.register_udtf(request.plan.command.register_table_function)
 
         case other:
-            raise SnowparkConnectNotImplementedError(
+            exception = 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()
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception