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

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

@@ -46,6 +46,9 @@ def map_read(
 
     Currently, the supported read formats are `csv`, `json` and `parquet`.
     """
+
+    materialize_df = True
+
     match rel.read.WhichOneof("read_type"):
         case "named_table":
             return map_read_table_or_file(rel)
@@ -99,6 +102,10 @@ def map_read(
                     for path in rel.read.data_source.paths
                 ]
 
+                # JSON already materializes the table internally
+                if read_format == "json":
+                    materialize_df = False
+
                 result = _read_file(
                     clean_source_paths, options, read_format, rel, schema, session
                 )
@@ -159,7 +166,9 @@ def map_read(
             raise SnowparkConnectNotImplementedError(f"Unsupported read type: {other}")
 
     return df_cache_map_put_if_absent(
-        (get_session_id(), rel.common.plan_id), lambda: result, materialize=True
+        (get_session_id(), rel.common.plan_id),
+        lambda: result,
+        materialize=materialize_df,
     )
 
 
@@ -205,6 +214,15 @@ def _get_supported_read_file_format(unparsed_identifier: str) -> str | None:
     return None
 
 
+def _quote_stage_path(stage_path: str) -> str:
+    """
+    Quote stage paths to escape any special characters.
+    """
+    if stage_path.startswith("@"):
+        return f"'{stage_path}'"
+    return stage_path
+
+
 def _read_file(
     clean_source_paths: list[str],
     options: dict,
@@ -218,6 +236,7 @@ def _read_file(
         session,
     )
     upload_files_if_needed(paths, clean_source_paths, session, read_format)
+    paths = [_quote_stage_path(path) for path in paths]
     match read_format:
         case "csv":
             from snowflake.snowpark_connect.relation.read.map_read_csv import (
@@ -285,8 +304,8 @@ def upload_files_if_needed(
 
     def _upload_dir(target: str, source: str) -> None:
         # overwrite=True will not remove all stale files in the target prefix
-
-        remove_command = f"REMOVE {target}/"
+        # Quote the target path to allow special characters.
+        remove_command = f"REMOVE '{target}/'"
         assert (
             "//" not in remove_command
         ), f"Remove command {remove_command} contains double slash"

snowflake/snowpark_connect/relation/read/map_read_csv.py

@@ -3,6 +3,7 @@
 #
 
 import copy
+from typing import Any
 
 import pyspark.sql.connect.proto.relations_pb2 as relation_proto
 
@@ -16,6 +17,7 @@ from snowflake.snowpark_connect.relation.read.utils import (
     get_spark_column_names_from_snowpark_columns,
     rename_columns_as_snowflake_standard,
 )
+from snowflake.snowpark_connect.utils.io_utils import cached_file_format
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
@@ -42,21 +44,34 @@ def map_read_csv(
         )
     else:
         snowpark_options = options.convert_to_snowpark_args()
+        parse_header = snowpark_options.get("PARSE_HEADER", False)
+        file_format_options = _parse_csv_snowpark_options(snowpark_options)
+        file_format = cached_file_format(session, "csv", file_format_options)
+
+        snowpark_read_options = dict()
+        snowpark_read_options["FORMAT_NAME"] = file_format
+        snowpark_read_options["ENFORCE_EXISTING_FILE_FORMAT"] = True
+        snowpark_read_options["INFER_SCHEMA"] = snowpark_options.get(
+            "INFER_SCHEMA", False
+        )
+        snowpark_read_options["PATTERN"] = snowpark_options.get("PATTERN", None)
+
         raw_options = rel.read.data_source.options
         if schema is None or (
-            snowpark_options.get("PARSE_HEADER", False)
-            and raw_options.get("enforceSchema", "True").lower() == "false"
+            parse_header and raw_options.get("enforceSchema", "True").lower() == "false"
         ):  # Schema has to equals to header's format
-            reader = session.read.options(snowpark_options)
+            reader = session.read.options(snowpark_read_options)
         else:
-            reader = session.read.options(snowpark_options).schema(schema)
+            reader = session.read.options(snowpark_read_options).schema(schema)
         df = read_data(
             reader,
             schema,
             session,
             paths[0],
-            snowpark_options,
+            file_format_options,
+            snowpark_read_options,
             raw_options,
+            parse_header,
         )
         if len(paths) > 1:
             # TODO: figure out if this is what Spark does.
@@ -81,15 +96,65 @@ def map_read_csv(
         )
 
 
+_csv_file_format_allowed_options = {
+    "COMPRESSION",
+    "RECORD_DELIMITER",
+    "FIELD_DELIMITER",
+    "MULTI_LINE",
+    "FILE_EXTENSION",
+    "PARSE_HEADER",
+    "SKIP_HEADER",
+    "SKIP_BLANK_LINES",
+    "DATE_FORMAT",
+    "TIME_FORMAT",
+    "TIMESTAMP_FORMAT",
+    "BINARY_FORMAT",
+    "ESCAPE",
+    "ESCAPE_UNENCLOSED_FIELD",
+    "TRIM_SPACE",
+    "FIELD_OPTIONALLY_ENCLOSED_BY",
+    "NULL_IF",
+    "ERROR_ON_COLUMN_COUNT_MISMATCH",
+    "REPLACE_INVALID_CHARACTERS",
+    "EMPTY_FIELD_AS_NULL",
+    "SKIP_BYTE_ORDER_MARK",
+    "ENCODING",
+}
+
+
+def _parse_csv_snowpark_options(snowpark_options: dict[str, Any]) -> dict[str, Any]:
+    file_format_options = dict()
+    for key, value in snowpark_options.items():
+        upper_key = key.upper()
+        if upper_key in _csv_file_format_allowed_options:
+            file_format_options[upper_key] = value
+
+    # This option has to be removed, because we cannot use at the same time predefined file format and parse_header option
+    # Such combination causes snowpark to raise SQL compilation error: Invalid file format "PARSE_HEADER" is only allowed for CSV INFER_SCHEMA and MATCH_BY_COLUMN_NAME
+    parse_header = file_format_options.get("PARSE_HEADER", False)
+    if parse_header:
+        file_format_options["SKIP_HEADER"] = 1
+        del file_format_options["PARSE_HEADER"]
+
+    return file_format_options
+
+
 def get_header_names(
     session: snowpark.Session,
     path: list[str],
-    snowpark_options: dict,
+    file_format_options: dict,
+    snowpark_read_options: dict,
 ) -> list[str]:
-    snowpark_options_no_header = copy.copy(snowpark_options)
-    snowpark_options_no_header["PARSE_HEADER"] = False
+    no_header_file_format_options = copy.copy(file_format_options)
+    no_header_file_format_options["PARSE_HEADER"] = False
+    no_header_file_format_options.pop("SKIP_HEADER", None)
+
+    file_format = cached_file_format(session, "csv", no_header_file_format_options)
+    no_header_snowpark_read_options = copy.copy(snowpark_read_options)
+    no_header_snowpark_read_options["FORMAT_NAME"] = file_format
+    no_header_snowpark_read_options.pop("INFER_SCHEMA", None)
 
-    header_df = session.read.options(snowpark_options_no_header).csv(path).limit(1)
+    header_df = session.read.options(no_header_snowpark_read_options).csv(path).limit(1)
     header_data = header_df.collect()[0]
     return [
         f'"{header_data[i]}"'
@@ -103,8 +168,10 @@ def read_data(
     schema: snowpark.types.StructType | None,
     session: snowpark.Session,
     path: list[str],
-    snowpark_options: dict,
+    file_format_options: dict,
+    snowpark_read_options: dict,
     raw_options: dict,
+    parse_header: bool,
 ) -> snowpark.DataFrame:
     df = reader.csv(path)
     filename = path.strip("/").split("/")[-1]
@@ -120,23 +187,35 @@ def read_data(
                     raise Exception("CSV header does not conform to the schema")
         return df
 
-    headers = get_header_names(session, path, snowpark_options)
-
+    headers = get_header_names(
+        session, path, file_format_options, snowpark_read_options
+    )
+
+    df_schema_fields = df.schema.fields
+    if len(headers) == len(df_schema_fields) and parse_header:
+        return df.select(
+            [
+                snowpark_fn.col(df_schema_fields[i].name).alias(headers[i])
+                for i in range(len(headers))
+            ]
+        )
     # Handle mismatch in column count between header and data
-    if (
-        len(df.schema.fields) == 1
-        and df.schema.fields[0].name.upper() == "C1"
-        and snowpark_options.get("PARSE_HEADER") is True
-        and len(headers) != len(df.schema.fields)
+    elif (
+        len(df_schema_fields) == 1
+        and df_schema_fields[0].name.upper() == "C1"
+        and parse_header
+        and len(headers) != len(df_schema_fields)
     ):
-        df = (
-            session.read.options(snowpark_options)
-            .schema(StructType([StructField(h, StringType(), True) for h in headers]))
-            .csv(path)
+        df = reader.schema(
+            StructType([StructField(h, StringType(), True) for h in headers])
+        ).csv(path)
+    elif not parse_header and len(headers) != len(df_schema_fields):
+        return df.select([df_schema_fields[i].name for i in range(len(headers))])
+    elif parse_header and len(headers) != len(df_schema_fields):
+        return df.select(
+            [
+                snowpark_fn.col(df_schema_fields[i].name).alias(headers[i])
+                for i in range(len(headers))
+            ]
         )
-    elif snowpark_options.get("PARSE_HEADER") is False and len(headers) != len(
-        df.schema.fields
-    ):
-        return df.select([df.schema.fields[i].name for i in range(len(headers))])
-
     return df

snowflake/snowpark_connect/relation/read/map_read_json.py

@@ -2,9 +2,12 @@
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
 
+import concurrent.futures
 import copy
 import json
+import os
 import typing
+import uuid
 from contextlib import suppress
 from datetime import datetime
 
@@ -253,20 +256,20 @@ def merge_row_schema(
     return schema
 
 
-def union_data_into_df(
-    result_df: snowpark.DataFrame,
-    data: typing.List[Row],
-    schema: StructType,
+def insert_data_chunk(
     session: snowpark.Session,
-) -> snowpark.DataFrame:
-    current_df = session.create_dataframe(
+    data: list[Row],
+    schema: StructType,
+    table_name: str,
+) -> None:
+    df = session.create_dataframe(
         data=data,
         schema=schema,
     )
-    if result_df is None:
-        return current_df
 
-    return result_df.union(current_df)
+    df.write.mode("append").save_as_table(
+        table_name, table_type="temp", table_exists=True
+    )
 
 
 def construct_dataframe_by_schema(
@@ -276,39 +279,47 @@ def construct_dataframe_by_schema(
     snowpark_options: dict,
     batch_size: int = 1000,
 ) -> snowpark.DataFrame:
-    result = None
+    table_name = "__sas_json_read_temp_" + uuid.uuid4().hex
+
+    # We can have more workers than CPU count, this is an IO-intensive task
+    max_workers = min(16, os.cpu_count() * 2)
 
     current_data = []
     progress = 0
-    for row in rows:
-        current_data.append(construct_row_by_schema(row, schema, snowpark_options))
-        if len(current_data) >= batch_size:
+
+    # Initialize the temp table
+    session.create_dataframe([], schema=schema).write.mode("append").save_as_table(
+        table_name, table_type="temp", table_exists=False
+    )
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as exc:
+        for row in rows:
+            current_data.append(construct_row_by_schema(row, schema, snowpark_options))
+            if len(current_data) >= batch_size:
+                progress += len(current_data)
+                exc.submit(
+                    insert_data_chunk,
+                    session,
+                    copy.deepcopy(current_data),
+                    schema,
+                    table_name,
+                )
+
+                logger.info(f"JSON reader: finished processing {progress} rows")
+                current_data.clear()
+
+        if len(current_data) > 0:
             progress += len(current_data)
-            result = union_data_into_df(
-                result,
-                current_data,
-                schema,
+            exc.submit(
+                insert_data_chunk,
                 session,
+                copy.deepcopy(current_data),
+                schema,
+                table_name,
             )
-
             logger.info(f"JSON reader: finished processing {progress} rows")
-            current_data = []
-
-    if len(current_data) > 0:
-        progress += len(current_data)
-        result = union_data_into_df(
-            result,
-            current_data,
-            schema,
-            session,
-        )
-
-        logger.info(f"JSON reader: finished processing {progress} rows")
-        current_data = []
 
-    if result is None:
-        raise ValueError("Dataframe cannot be empty")
-    return result
+    return session.table(table_name)
 
 
 def construct_row_by_schema(

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