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

snowflake/snowpark_connect/relation/map_sql.py

@@ -2,16 +2,21 @@
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
 
+import math
 import re
+import typing
 from collections.abc import MutableMapping, MutableSequence
-from contextlib import contextmanager
+from contextlib import contextmanager, suppress
 from contextvars import ContextVar
+from decimal import Decimal
 from functools import reduce
+from typing import Tuple
 
 import jpype
 import pandas
 import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
 import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+import pyspark.sql.connect.proto.types_pb2 as types_proto
 import sqlglot
 from google.protobuf.any_pb2 import Any
 from pyspark.errors.exceptions.base import (
@@ -24,20 +29,28 @@ import snowflake.snowpark.functions as snowpark_fn
 import snowflake.snowpark_connect.proto.snowflake_expression_ext_pb2 as snowflake_exp_proto
 import snowflake.snowpark_connect.proto.snowflake_relation_ext_pb2 as snowflake_proto
 from snowflake import snowpark
+from snowflake.snowpark import Session, types as snowpark_types
 from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     quote_name_without_upper_casing,
     unquote_if_quoted,
 )
 from snowflake.snowpark._internal.type_utils import convert_sp_to_sf_type
 from snowflake.snowpark._internal.utils import is_sql_select_statement, quote_name
+from snowflake.snowpark.functions import when_matched, when_not_matched
 from snowflake.snowpark_connect.config import (
+    auto_uppercase_column_identifiers,
     auto_uppercase_non_column_identifiers,
+    check_table_supports_operation,
     get_boolean_session_config_param,
     global_config,
+    record_table_metadata,
     set_config_param,
+    should_create_temporary_view_in_snowflake,
     unset_config_param,
 )
 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.expression.map_expression import (
     ColumnNameMap,
     map_single_column_expression,
@@ -51,14 +64,28 @@ from snowflake.snowpark_connect.relation.map_relation import (
     NATURAL_JOIN_TYPE_BASE,
     map_relation,
 )
-from snowflake.snowpark_connect.type_mapping import map_snowpark_to_pyspark_types
+
+# Import from utils for consistency
+from snowflake.snowpark_connect.relation.utils import is_aggregate_function
+from snowflake.snowpark_connect.snowflake_session import (
+    SQL_PASS_THROUGH_MARKER,
+    calculate_checksum,
+)
+from snowflake.snowpark_connect.type_mapping import (
+    map_snowpark_to_pyspark_types,
+    snowpark_to_proto_type,
+)
 from snowflake.snowpark_connect.utils.context import (
     _accessing_temp_object,
     gen_sql_plan_id,
-    get_session_id,
+    get_is_processing_aliased_relation,
+    get_spark_session_id,
     get_sql_plan,
     push_evaluating_sql_scope,
+    push_processed_view,
+    push_processing_aliased_relation_scope,
     push_sql_scope,
+    set_plan_id_map,
     set_sql_args,
     set_sql_plan_name,
 )
@@ -68,6 +95,7 @@ from snowflake.snowpark_connect.utils.telemetry import (
     telemetry,
 )
 
+from .. import column_name_handler
 from ..expression.map_sql_expression import (
     _window_specs,
     as_java_list,
@@ -75,7 +103,18 @@ from ..expression.map_sql_expression import (
     map_logical_plan_expression,
     sql_parser,
 )
-from ..utils.identifiers import spark_to_sf_single_id
+from ..typed_column import TypedColumn
+from ..utils.identifiers import (
+    spark_to_sf_single_id,
+    spark_to_sf_single_id_with_unquoting,
+)
+from ..utils.temporary_view_helper import (
+    create_snowflake_temporary_view,
+    get_temp_view,
+    store_temporary_view_as_dataframe,
+    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={})
@@ -84,6 +123,65 @@ _having_condition = ContextVar[expressions_proto.Expression | None](
 )
 
 
+def _map_value_to_literal_proto(
+    value: typing.Any, typ: snowpark_types.DataType
+) -> expressions_proto.Expression.Literal:
+    if isinstance(typ, snowpark_types.NullType):
+        return expressions_proto.Expression.Literal(null=value)
+    if isinstance(typ, snowpark_types.BinaryType):
+        return expressions_proto.Expression.Literal(binary=value)
+    if isinstance(typ, snowpark_types.BooleanType):
+        return expressions_proto.Expression.Literal(boolean=value)
+    if isinstance(typ, snowpark_types.ByteType):
+        return expressions_proto.Expression.Literal(byte=value)
+    if isinstance(typ, snowpark_types.ShortType):
+        return expressions_proto.Expression.Literal(short=value)
+    if isinstance(typ, snowpark_types.IntegerType):
+        return expressions_proto.Expression.Literal(integer=value)
+    if isinstance(typ, snowpark_types.LongType):
+        return expressions_proto.Expression.Literal(long=value)
+    if isinstance(typ, snowpark_types.FloatType):
+        return expressions_proto.Expression.Literal(float=value)
+    if isinstance(typ, snowpark_types.DoubleType):
+        return expressions_proto.Expression.Literal(double=value)
+    if isinstance(typ, snowpark_types.DecimalType):
+        return expressions_proto.Expression.Literal(
+            decimal=expressions_proto.Expression.Literal.Decimal(
+                value=value,
+                precision=typ.precision,
+                scale=typ.scale,
+            )
+        )
+    if isinstance(typ, snowpark_types.ArrayType):
+        element_type_proto = types_proto.DataType(
+            **snowpark_to_proto_type(typ.element_type)
+        )
+
+        return expressions_proto.Expression.Literal(
+            array=expressions_proto.Expression.Literal.Array(
+                element_type=element_type_proto,
+                elements=[
+                    _map_value_to_literal_proto(el, typ.element_type) for el in value
+                ],
+            )
+        )
+
+    if isinstance(typ, snowpark_types.StructType):
+        struct_type_proto = types_proto.DataType(**snowpark_to_proto_type(typ))
+
+        return expressions_proto.Expression.Literal(
+            struct=expressions_proto.Expression.Literal.Struct(
+                struct_type=struct_type_proto,
+                elements=[
+                    _map_value_to_literal_proto(v, typ.fields[i].datatype)
+                    for i, v in enumerate(value.values())
+                ],
+            )
+        )
+
+    return expressions_proto.Expression.Literal(string=str(value))
+
+
 def _is_sql_select_statement_helper(sql_string: str) -> bool:
     """
     Determine if a SQL string is a SELECT or CTE query statement, even when it starts with comments or whitespace.
@@ -130,6 +228,48 @@ def _push_cte_scope():
         _cte_definitions.reset(def_token)
 
 
+def _process_cte_relations(cte_relations):
+    """
+    Process CTE relations and register them in the current CTE scope.
+
+    This function extracts CTE definitions from CTE relations,
+    maps them to protobuf representations, and stores them for later reference.
+
+    Args:
+        cte_relations: Java list of CTE relations (tuples of name and SubqueryAlias)
+    """
+    for cte in as_java_list(cte_relations):
+        name = str(cte._1())
+        # Store the original CTE definition for re-evaluation
+        _cte_definitions.get()[name] = cte._2()
+        # Process CTE definition with a unique plan_id to ensure proper column naming
+        # Clear HAVING condition before processing each CTE to prevent leakage between CTEs
+        saved_having = _having_condition.get()
+        _having_condition.set(None)
+        try:
+            cte_plan_id = gen_sql_plan_id()
+            cte_proto = map_logical_plan_relation(cte._2(), cte_plan_id)
+            _ctes.get()[name] = cte_proto
+        finally:
+            _having_condition.set(saved_having)
+
+
+@contextmanager
+def _with_cte_scope(cte_relations):
+    """
+    Context manager that creates a CTE scope and processes CTE relations.
+
+    This combines _push_cte_scope() and _process_cte_relations() to handle
+    the common pattern of processing CTEs within a new scope.
+
+    Args:
+        cte_relations: Java list of CTE relations (tuples of name and SubqueryAlias)
+    """
+    with (_push_cte_scope()):
+        _process_cte_relations(cte_relations)
+        yield
+
+
 @contextmanager
 def _push_window_specs_scope():
     """
@@ -203,6 +343,9 @@ def _rename_columns(
 def _create_table_as_select(logical_plan, mode: str) -> None:
     # TODO: for as select create tables we'd map multi layer identifier here
     name = get_relation_identifier_name(logical_plan.name())
+    full_table_identifier = get_relation_identifier_name(
+        logical_plan.name(), is_multi_part=True
+    )
     comment = logical_plan.tableSpec().comment()
 
     container = execute_logical_plan(logical_plan.query())
@@ -223,9 +366,158 @@ def _create_table_as_select(logical_plan, mode: str) -> None:
         mode=mode,
     )
 
+    # Record table metadata for CREATE TABLE AS SELECT
+    # These are typically considered v2 tables and support RENAME COLUMN
+    record_table_metadata(
+        table_identifier=full_table_identifier,
+        table_type="v2",
+        data_source="default",
+        supports_column_rename=True,
+    )
+
+
+def _insert_into_table(logical_plan, session: Session) -> None:
+    df_container = execute_logical_plan(logical_plan.query())
+    df = df_container.dataframe
+    queries = df.queries["queries"]
+    if len(queries) != 1:
+        exception = SnowparkConnectNotImplementedError(
+            f"Unexpected number of queries: {len(queries)}"
+        )
+        attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+        raise exception
+
+    name = get_relation_identifier_name(logical_plan.table(), True)
+
+    user_columns = [
+        spark_to_sf_single_id(str(col), is_column=True)
+        for col in as_java_list(logical_plan.userSpecifiedCols())
+    ]
+    overwrite_str = "OVERWRITE" if logical_plan.overwrite() else ""
+    cols_str = "(" + ", ".join(user_columns) + ")" if user_columns else ""
+
+    # Extract partition spec if any
+    partition_spec = logical_plan.partitionSpec()
+    partition_map = as_java_map(partition_spec)
+
+    partition_columns = {}
+    for entry in partition_map.entrySet():
+        col_name = str(entry.getKey())
+        value_option = entry.getValue()
+        if value_option.isDefined():
+            partition_columns[col_name] = value_option.get()
+
+    target_table = session.table(name)
+    target_schema = target_table.schema
+
+    # Add partition columns to the dataframe
+    if partition_columns:
+        """
+        Spark sends them in the partition spec and the values won't be present in the values array.
+        As snowflake does not support static partitions in INSERT INTO statements,
+        we need to add the partition columns to the dataframe as literal columns.
+
+        ex: INSERT INTO TABLE test_table PARTITION (ds='2021-01-01', hr=10) VALUES ('k1', 100), ('k2', 200), ('k3', 300)
+
+        Spark sends: VALUES ('k1', 100), ('k2', 200), ('k3', 300) with partition spec (ds='2021-01-01', hr=10)
+        Snowflake expects: VALUES ('k1', 100, '2021-01-01', 10), ('k2', 200, '2021-01-01', 10), ('k3', 300, '2021-01-01', 10)
+
+        We need to add the partition columns to the dataframe as literal columns.
+
+        ex: df = df.withColumn('ds', snowpark_fn.lit('2021-01-01'))
+            df = df.withColumn('hr', snowpark_fn.lit(10))
+
+        Then the final query will be:
+        INSERT INTO TABLE test_table VALUES ('k1', 100, '2021-01-01', 10), ('k2', 200, '2021-01-01', 10), ('k3', 300, '2021-01-01', 10)
+        """
+        for partition_col, partition_value in partition_columns.items():
+
+            def _comparable_col_name(col: str) -> str:
+                name = col.upper() if auto_uppercase_column_identifiers() else col
+                return unquote_if_quoted(name)
+
+            comparable_target_schema = [
+                _comparable_col_name(col.name) for col in target_schema.fields
+            ]
+
+            if _comparable_col_name(partition_col) not in comparable_target_schema:
+                exception = AnalysisException(
+                    f"{partition_col} is not a valid partition column in table {name}."
+                )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
+            df = df.withColumn(partition_col, snowpark_fn.lit(partition_value))
+
+    expected_number_of_columns = (
+        len(user_columns) if user_columns else len(target_schema.fields)
+    )
+    if expected_number_of_columns != len(df.schema.fields):
+        reason = (
+            "too many data columns"
+            if len(df.schema.fields) > expected_number_of_columns
+            else "not enough data columns"
+        )
+        exception = AnalysisException(
+            f'[INSERT_COLUMN_ARITY_MISMATCH.{reason.replace(" ", "_").upper()}] Cannot write to {name}, the reason is {reason}:\n'
+            f'Table columns: {", ".join(target_schema.names)}.\n'
+            f'Data columns: {", ".join(df.schema.names)}.'
+        )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
+
+    try:
+        # Modify df with type conversions and struct field name mapping
+        modified_columns = []
+        for source_field, target_field in zip(df.schema.fields, target_schema.fields):
+            col_name = source_field.name
+
+            # Handle different type conversions
+            if isinstance(
+                target_field.datatype, snowpark.types.DecimalType
+            ) and isinstance(
+                source_field.datatype,
+                (snowpark.types.FloatType, snowpark.types.DoubleType),
+            ):
+                # Add CASE WHEN to convert NaN to NULL for DECIMAL targets
+                # Only apply this to floating-point source columns
+                modified_col = (
+                    snowpark_fn.when(
+                        snowpark_fn.equal_nan(snowpark_fn.col(col_name)),
+                        snowpark_fn.lit(None),
+                    )
+                    .otherwise(snowpark_fn.col(col_name))
+                    .alias(col_name)
+                )
+                modified_columns.append(modified_col)
+            elif (
+                isinstance(target_field.datatype, snowpark.types.StructType)
+                and source_field.datatype != target_field.datatype
+            ):
+                # Cast struct with field name mapping (e.g., col1,col2 -> i1,i2)
+                # This fixes INSERT INTO table with struct literals like (2, 3)
+                modified_col = (
+                    snowpark_fn.col(col_name)
+                    .cast(target_field.datatype, rename_fields=True)
+                    .alias(col_name)
+                )
+                modified_columns.append(modified_col)
+            else:
+                modified_columns.append(snowpark_fn.col(col_name))
+
+        df = df.select(modified_columns)
+    except Exception:
+        pass
+
+    queries = df.queries["queries"]
+    final_query = queries[0]
+    session.sql(
+        f"INSERT {overwrite_str} INTO {name} {cols_str} {final_query}",
+    ).collect()
+
 
 def _spark_field_to_sql(field: jpype.JObject, is_column: bool) -> str:
-    # Column names will be uppercased according to "snowpark.connect.sql.identifiers.auto-uppercase",
+    # Column names will be uppercased according to "snowpark.connect.sql.identifiers.auto-uppercase"
+    # if present, or to "spark.sql.caseSensitive".
     # and struct fields will be left as is. This should allow users to use the same names
     # in spark and Snowflake in most cases.
     if is_column:
@@ -300,6 +592,69 @@ def _remove_column_data_type(node):
     return node
 
 
+def _get_condition_from_action(action, column_mapping, typer):
+    condition = None
+    if action.condition().isDefined():
+        (_, condition_typed_col,) = map_single_column_expression(
+            map_logical_plan_expression(action.condition().get()),
+            column_mapping,
+            typer,
+        )
+        condition = condition_typed_col.col
+    return condition
+
+
+def _get_assignments_from_action(
+    action,
+    column_mapping_source,
+    column_mapping_target,
+    typer_source,
+    typer_target,
+):
+    assignments = dict()
+    if (
+        action.getClass().getSimpleName() == "InsertAction"
+        or action.getClass().getSimpleName() == "UpdateAction"
+    ):
+        incoming_assignments = as_java_list(action.assignments())
+        for assignment in incoming_assignments:
+            (_, key_typ_col) = map_single_column_expression(
+                map_logical_plan_expression(assignment.key()),
+                column_mapping=column_mapping_target,
+                typer=typer_target,
+            )
+            key_name = typer_target.df.select(key_typ_col.col).columns[0]
+
+            (_, val_typ_col) = map_single_column_expression(
+                map_logical_plan_expression(assignment.value()),
+                column_mapping=column_mapping_source,
+                typer=typer_source,
+            )
+
+            assignments[key_name] = val_typ_col.col
+    elif (
+        action.getClass().getSimpleName() == "InsertStarAction"
+        or action.getClass().getSimpleName() == "UpdateStarAction"
+    ):
+        if len(column_mapping_source.columns) != len(column_mapping_target.columns):
+            exception = ValueError(
+                "source and target must have the same number of columns for InsertStarAction or UpdateStarAction"
+            )
+            attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+            raise exception
+        for i, col in enumerate(column_mapping_target.columns):
+            if assignments.get(col.snowpark_name) is not None:
+                exception = SnowparkConnectNotImplementedError(
+                    "UpdateStarAction or InsertStarAction is not supported with duplicate columns."
+                )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
+            assignments[col.snowpark_name] = snowpark_fn.col(
+                column_mapping_source.columns[i].snowpark_name
+            )
+    return assignments
+
+
 def map_sql_to_pandas_df(
     sql_string: str,
     named_args: MutableMapping[str, expressions_proto.Expression.Literal],
@@ -311,7 +666,7 @@ def map_sql_to_pandas_df(
     returns a tuple of None for SELECT queries to enable lazy evaluation
     """
 
-    snowpark_connect_sql_passthrough = get_sql_passthrough()
+    snowpark_connect_sql_passthrough, sql_string = is_valid_passthrough_sql(sql_string)
 
     if not snowpark_connect_sql_passthrough:
         logical_plan = sql_parser().parsePlan(sql_string)
@@ -327,6 +682,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
@@ -397,9 +753,11 @@ def map_sql_to_pandas_df(
                     snowflake_sql = f"ALTER TABLE {table_name} ALTER COLUMN {column_name} {alter_clause}"
                     session.sql(snowflake_sql).collect()
                 else:
-                    raise ValueError(
+                    exception = ValueError(
                         f"No alter operations found in AlterColumn logical plan for table {table_name}, column {column_name}"
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_SQL_SYNTAX)
+                    raise exception
             case "CreateNamespace":
                 name = get_relation_identifier_name(logical_plan.name(), True)
                 previous_name = session.connection.schema
@@ -421,6 +779,9 @@ def map_sql_to_pandas_df(
                     )
 
                 name = get_relation_identifier_name(logical_plan.name())
+                full_table_identifier = get_relation_identifier_name(
+                    logical_plan.name(), is_multi_part=True
+                )
                 columns = ", ".join(
                     _spark_field_to_sql(f, True)
                     for f in logical_plan.tableSchema().fields()
@@ -431,10 +792,48 @@ def map_sql_to_pandas_df(
                     if comment_opt.isDefined()
                     else ""
                 )
+
+                # Extract data source for metadata tracking
+                data_source = "default"
+
+                with suppress(Exception):
+                    # Get data source from tableSpec.provider() (for USING clause)
+                    if hasattr(logical_plan, "tableSpec"):
+                        table_spec = logical_plan.tableSpec()
+                        if hasattr(table_spec, "provider"):
+                            provider_opt = table_spec.provider()
+                            if provider_opt.isDefined():
+                                data_source = str(provider_opt.get()).lower()
+                        else:
+                            # Fall back to checking properties for FORMAT
+                            table_properties = table_spec.properties()
+                            if not table_properties.isEmpty():
+                                for prop in table_properties.get():
+                                    if str(prop.key()) == "FORMAT":
+                                        data_source = str(prop.value()).lower()
+                                        break
+
                 # NOTE: We are intentionally ignoring any FORMAT=... parameters here.
                 session.sql(
                     f"CREATE {replace_table} TABLE {if_not_exists}{name} ({columns}) {comment}"
                 ).collect()
+
+                # Record table metadata for Spark compatibility
+                # Tables created with explicit schema are considered v1 tables
+                # v1 tables with certain data sources don't support RENAME COLUMN in OSS Spark
+                supports_rename = data_source not in (
+                    "parquet",
+                    "csv",
+                    "json",
+                    "orc",
+                    "avro",
+                )
+                record_table_metadata(
+                    table_identifier=full_table_identifier,
+                    table_type="v1",
+                    data_source=data_source,
+                    supports_column_rename=supports_rename,
+                )
             case "CreateTableAsSelect":
                 mode = "ignore" if logical_plan.ignoreIfExists() else "errorifexists"
                 _create_table_as_select(logical_plan, mode=mode)
@@ -446,20 +845,62 @@ def map_sql_to_pandas_df(
                     f"CREATE TABLE {if_not_exists}{name} LIKE {source}"
                 ).collect()
             case "CreateTempViewUsing":
+                parsed_sql = sqlglot.parse_one(sql_string, dialect="spark")
+
+                spark_view_name = next(parsed_sql.find_all(sqlglot.exp.Table)).name
+
+                # extract ONLY top-level column definitions (not nested struct fields)
+                column_defs = []
+                schema_node = next(parsed_sql.find_all(sqlglot.exp.Schema), None)
+                if schema_node:
+                    for expr in schema_node.expressions:
+                        if isinstance(expr, sqlglot.exp.ColumnDef):
+                            column_defs.append(expr)
+
+                num_columns = len(column_defs)
+                if num_columns > 0:
+                    null_list_parts = []
+                    for col_def in column_defs:
+                        col_name = spark_to_sf_single_id(col_def.name, is_column=True)
+                        col_type = col_def.kind
+                        if col_type:
+                            null_list_parts.append(
+                                f"CAST(NULL AS {col_type.sql(dialect='snowflake')}) AS {col_name}"
+                            )
+                        else:
+                            null_list_parts.append(f"NULL AS {col_name}")
+                    null_list = ", ".join(null_list_parts)
+                else:
+                    null_list = "*"
+
                 empty_select = (
-                    " AS SELECT * WHERE 1 = 0"
+                    f" AS SELECT {null_list} WHERE 1 = 0"
                     if logical_plan.options().isEmpty()
                     and logical_plan.children().isEmpty()
                     else ""
                 )
-                parsed_sql = (
-                    sqlglot.parse_one(sql_string, dialect="spark")
-                    .transform(_normalize_identifiers)
+
+                transformed_sql = (
+                    parsed_sql.transform(_normalize_identifiers)
                     .transform(_remove_column_data_type)
                     .transform(_remove_file_format_property)
                 )
-                snowflake_sql = parsed_sql.sql(dialect="snowflake")
+                snowflake_sql = transformed_sql.sql(dialect="snowflake")
                 session.sql(f"{snowflake_sql}{empty_select}").collect()
+                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():
+                    exception = AnalysisException(
+                        f"[TEMP_TABLE_OR_VIEW_ALREADY_EXISTS] Cannot create the temporary view `{spark_view_name}` because it already exists."
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+                    raise exception
+                else:
+                    unregister_temp_view(
+                        spark_to_sf_single_id_with_unquoting(spark_view_name)
+                    )
             case "CreateView":
                 current_schema = session.connection.schema
                 if (
@@ -475,11 +916,13 @@ def map_sql_to_pandas_df(
                 df_container = execute_logical_plan(logical_plan.query())
                 df = df_container.dataframe
                 if _accessing_temp_object.get():
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"[INVALID_TEMP_OBJ_REFERENCE] Cannot create the persistent object `{CURRENT_CATALOG_NAME}`.`{current_schema}`.`{object_name}` "
                         "of the type VIEW because it references to a temporary object of the type VIEW. Please "
                         f"make the temporary object persistent, or make the persistent object `{CURRENT_CATALOG_NAME}`.`{current_schema}`.`{object_name}` temporary."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+                    raise exception
 
                 name = get_relation_identifier_name(logical_plan.child())
                 comment = logical_plan.comment()
@@ -496,58 +939,143 @@ 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
-                )
+                    is_global = isinstance(
+                        logical_plan.viewType(),
+                        jpype.JClass(
+                            "org.apache.spark.sql.catalyst.analysis.GlobalTempView$"
+                        ),
+                    )
 
-                df = _rename_columns(
-                    df, logical_plan.userSpecifiedColumns(), df_container.column_map
-                )
+                    def get_cached_view_name() -> str:
+                        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
+                        ]
+                        return ".".join(view_name)
+
+                    def get_snowflake_view_name() -> list[str]:
+                        snowpark_view_name = str(logical_plan.name().identifier())
+                        snowpark_view_name = spark_to_sf_single_id(snowpark_view_name)
+                        return (
+                            [
+                                global_config.spark_sql_globalTempDatabase,
+                                snowpark_view_name,
+                            ]
+                            if is_global
+                            else [snowpark_view_name]
+                        )
 
-                if logical_plan.replace():
-                    df.create_or_replace_temp_view(
-                        name,
-                        comment=maybe_comment,
-                    )
-                else:
-                    df.create_temp_view(
-                        name,
-                        comment=maybe_comment,
+                    snowflake_view_name = get_snowflake_view_name()
+                    cached_view_name = get_cached_view_name()
+
+                    tmp_views = _get_current_temp_objects()
+                    tmp_views.add(
+                        (
+                            CURRENT_CATALOG_NAME,
+                            session.connection.schema,
+                            str(logical_plan.name().identifier()),
+                        )
                     )
+
+                    def _create_snowflake_temporary_view():
+                        comment = logical_plan.comment()
+                        maybe_comment = (
+                            _escape_sql_comment(str(comment.get()))
+                            if comment.isDefined()
+                            else None
+                        )
+
+                        renamed_df = _rename_columns(
+                            df,
+                            logical_plan.userSpecifiedColumns(),
+                            df_container.column_map,
+                        )
+
+                        create_snowflake_temporary_view(
+                            renamed_df,
+                            snowflake_view_name,
+                            cached_view_name,
+                            logical_plan.replace(),
+                            maybe_comment,
+                        )
+
+                    if should_create_temporary_view_in_snowflake():
+                        _create_snowflake_temporary_view()
+                    else:
+                        user_specified_spark_column_names = [
+                            str(col._1())
+                            for col in as_java_list(logical_plan.userSpecifiedColumns())
+                        ]
+                        spark_column_names = (
+                            user_specified_spark_column_names
+                            if user_specified_spark_column_names
+                            else df_container.column_map.get_spark_columns()
+                        )
+                        store_temporary_view_as_dataframe(
+                            df,
+                            df_container.column_map,
+                            spark_column_names,
+                            df_container.column_map.get_snowpark_columns(),
+                            cached_view_name,
+                            snowflake_view_name,
+                            logical_plan.replace(),
+                        )
             case "DescribeColumn":
-                name = get_relation_identifier_name(logical_plan.column())
+                name = get_relation_identifier_name_without_uppercasing(
+                    logical_plan.column()
+                )
+                stored_temp_view = get_temp_view(name)
+                if stored_temp_view:
+                    return (
+                        SNOWFLAKE_CATALOG._list_columns_from_dataframe_container(
+                            stored_temp_view
+                        ),
+                        "",
+                    )
                 # 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)
-                name = change_default_to_public(name)
                 rows = session.sql(f"DESCRIBE SCHEMA {name}").collect()
                 if not rows:
                     rows = None
             case "DescribeRelation":
+                name = get_relation_identifier_name_without_uppercasing(
+                    logical_plan.relation(), True
+                )
+                stored_temp_view = get_temp_view(name)
+                if stored_temp_view:
+                    return (
+                        SNOWFLAKE_CATALOG._list_columns_from_dataframe_container(
+                            stored_temp_view
+                        ),
+                        "",
+                    )
+
                 name = get_relation_identifier_name(logical_plan.relation(), True)
                 rows = session.sql(f"DESCRIBE TABLE {name}").collect()
                 if not rows:
@@ -598,9 +1126,11 @@ def map_sql_to_pandas_df(
                     del session._udtfs[func_name]
                 else:
                     if not logical_plan.ifExists():
-                        raise ValueError(
+                        exception = ValueError(
                             f"Function {func_name} not found among registered UDFs or UDTFs."
                         )
+                        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                        raise exception
                 if snowpark_name != "":
                     argument_string = f"({', '.join(convert_sp_to_sf_type(arg) for arg in input_types)})"
                     session.sql(
@@ -615,9 +1145,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()
@@ -669,84 +1203,189 @@ def map_sql_to_pandas_df(
                     rows = session.sql(final_sql).collect()
                 else:
                     # TODO: Support other logical plans
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         f"{logical_plan_name} is not supported yet with EXPLAIN."
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
             case "InsertIntoStatement":
-                df_container = execute_logical_plan(logical_plan.query())
-                df = df_container.dataframe
-                queries = df.queries["queries"]
-                if len(queries) != 1:
-                    raise SnowparkConnectNotImplementedError(
-                        f"Unexpected number of queries: {len(queries)}"
+                _insert_into_table(logical_plan, session)
+            case "MergeIntoTable":
+                source_df_container = map_relation(
+                    map_logical_plan_relation(logical_plan.sourceTable())
+                )
+                source_df = source_df_container.dataframe
+                plan_id = gen_sql_plan_id()
+                target_df_container = map_relation(
+                    map_logical_plan_relation(logical_plan.targetTable(), plan_id)
+                )
+                target_df = target_df_container.dataframe
+
+                if (
+                    logical_plan.targetTable().getClass().getSimpleName()
+                    == "UnresolvedRelation"
+                ):
+                    target_table_name = _spark_to_snowflake(
+                        logical_plan.targetTable().multipartIdentifier()
+                    )
+                else:
+                    target_table_name = _spark_to_snowflake(
+                        logical_plan.targetTable().child().multipartIdentifier()
                     )
 
-                name = get_relation_identifier_name(logical_plan.table(), True)
+                target_table = session.table(target_table_name)
+                target_table_columns = target_table.columns
+                target_df_spark_names = []
+                for target_table_col, target_df_col in zip(
+                    target_table_columns, target_df_container.column_map.columns
+                ):
+                    target_df = target_df.with_column_renamed(
+                        target_df_col.snowpark_name,
+                        target_table_col,
+                    )
+                    target_df_spark_names.append(target_df_col.spark_name)
+                target_df_container = DataFrameContainer.create_with_column_mapping(
+                    dataframe=target_df,
+                    spark_column_names=target_df_spark_names,
+                    snowpark_column_names=target_table_columns,
+                )
 
-                user_columns = [
-                    spark_to_sf_single_id(str(col), is_column=True)
-                    for col in as_java_list(logical_plan.userSpecifiedCols())
-                ]
-                overwrite_str = "OVERWRITE" if logical_plan.overwrite() else ""
-                cols_str = "(" + ", ".join(user_columns) + ")" if user_columns else ""
+                set_plan_id_map(plan_id, target_df_container)
 
-                try:
-                    target_table = session.table(name)
-                    target_schema = target_table.schema
+                joined_df_before_condition: snowpark.DataFrame = source_df.join(
+                    target_df
+                )
 
-                    # Modify df with NaN → NULL conversion for DECIMAL columns
-                    modified_columns = []
-                    for source_field, target_field in zip(
-                        df.schema.fields, target_schema.fields
-                    ):
-                        col_name = source_field.name
-                        if isinstance(
-                            target_field.datatype, snowpark.types.DecimalType
-                        ) and isinstance(
-                            source_field.datatype,
-                            (snowpark.types.FloatType, snowpark.types.DoubleType),
-                        ):
-                            # Add CASE WHEN to convert NaN to NULL for DECIMAL targets
-                            # Only apply this to floating-point source columns
-                            modified_col = (
-                                snowpark_fn.when(
-                                    snowpark_fn.equal_nan(snowpark_fn.col(col_name)),
-                                    snowpark_fn.lit(None),
-                                )
-                                .otherwise(snowpark_fn.col(col_name))
-                                .alias(col_name)
-                            )
-                            modified_columns.append(modified_col)
-                        else:
-                            modified_columns.append(snowpark_fn.col(col_name))
+                column_mapping_for_conditions = column_name_handler.JoinColumnNameMap(
+                    source_df_container.column_map,
+                    target_df_container.column_map,
+                )
+                typer_for_expressions = ExpressionTyper(joined_df_before_condition)
 
-                    df = df.select(modified_columns)
-                except Exception:
-                    pass
-                queries = df.queries["queries"]
-                final_query = queries[0]
-                session.sql(
-                    f"INSERT {overwrite_str} INTO {name} {cols_str} {final_query}",
-                ).collect()
-            case "MergeIntoTable":
-                raise UnsupportedOperationException(
-                    "[UNSUPPORTED_SQL_EXTENSION] The MERGE INTO command failed.\n"
-                    + "Reason: This command is a platform-specific SQL extension and is not part of the standard Apache Spark specification that this interface uses."
+                (_, merge_condition_typed_col,) = map_single_column_expression(
+                    map_logical_plan_expression(logical_plan.mergeCondition()),
+                    column_mapping=column_mapping_for_conditions,
+                    typer=typer_for_expressions,
                 )
+
+                clauses = []
+
+                for matched_action in as_java_list(logical_plan.matchedActions()):
+                    condition = _get_condition_from_action(
+                        matched_action,
+                        column_mapping_for_conditions,
+                        typer_for_expressions,
+                    )
+                    if matched_action.getClass().getSimpleName() == "DeleteAction":
+                        clauses.append(when_matched(condition).delete())
+                    elif (
+                        matched_action.getClass().getSimpleName() == "UpdateAction"
+                        or matched_action.getClass().getSimpleName()
+                        == "UpdateStarAction"
+                    ):
+                        assignments = _get_assignments_from_action(
+                            matched_action,
+                            source_df_container.column_map,
+                            target_df_container.column_map,
+                            ExpressionTyper(source_df),
+                            ExpressionTyper(target_df),
+                        )
+                        clauses.append(when_matched(condition).update(assignments))
+
+                for not_matched_action in as_java_list(
+                    logical_plan.notMatchedActions()
+                ):
+                    condition = _get_condition_from_action(
+                        not_matched_action,
+                        column_mapping_for_conditions,
+                        typer_for_expressions,
+                    )
+                    if (
+                        not_matched_action.getClass().getSimpleName() == "InsertAction"
+                        or not_matched_action.getClass().getSimpleName()
+                        == "InsertStarAction"
+                    ):
+                        assignments = _get_assignments_from_action(
+                            not_matched_action,
+                            source_df_container.column_map,
+                            target_df_container.column_map,
+                            ExpressionTyper(source_df),
+                            ExpressionTyper(target_df),
+                        )
+                        clauses.append(when_not_matched(condition).insert(assignments))
+
+                if not as_java_list(logical_plan.notMatchedBySourceActions()).isEmpty():
+                    exception = SnowparkConnectNotImplementedError(
+                        "Snowflake does not support 'not matched by source' actions in MERGE statements."
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
+
+                target_table.merge(source_df, merge_condition_typed_col.col, clauses)
             case "DeleteFromTable":
-                raise UnsupportedOperationException(
-                    "[UNSUPPORTED_SQL_EXTENSION] The DELETE FROM command failed.\n"
-                    + "Reason: This command is a platform-specific SQL extension and is not part of the standard Apache Spark specification that this interface uses."
+                df_container = map_relation(
+                    map_logical_plan_relation(logical_plan.table())
                 )
+                name = get_relation_identifier_name(logical_plan.table(), True)
+                table = session.table(name)
+                table_columns = table.columns
+                df = df_container.dataframe
+                spark_names = []
+                for table_col, df_col in zip(
+                    table_columns, df_container.column_map.columns
+                ):
+                    df = df.with_column_renamed(
+                        df_col.snowpark_name,
+                        table_col,
+                    )
+                    spark_names.append(df_col.spark_name)
+                df_container = DataFrameContainer.create_with_column_mapping(
+                    dataframe=df,
+                    spark_column_names=spark_names,
+                    snowpark_column_names=table_columns,
+                )
+                df = df_container.dataframe
+                (
+                    condition_column_name,
+                    condition_typed_col,
+                ) = map_single_column_expression(
+                    map_logical_plan_expression(logical_plan.condition()),
+                    df_container.column_map,
+                    ExpressionTyper(df),
+                )
+                table.delete(condition_typed_col.col)
             case "UpdateTable":
                 # Databricks/Delta-specific extension not supported by SAS.
                 # Provide an actionable, clear error.
-                raise UnsupportedOperationException(
+                exception = UnsupportedOperationException(
                     "[UNSUPPORTED_SQL_EXTENSION] The UPDATE TABLE command failed.\n"
                     + "Reason: This command is a platform-specific SQL extension and is not part of the standard Apache Spark specification that this interface uses."
                 )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
             case "RenameColumn":
-                table_name = get_relation_identifier_name(logical_plan.table(), True)
+                full_table_identifier = get_relation_identifier_name(
+                    logical_plan.table(), True
+                )
+
+                # Check Spark compatibility for RENAME COLUMN operation
+                if not check_table_supports_operation(
+                    full_table_identifier, "rename_column"
+                ):
+                    exception = AnalysisException(
+                        f"ALTER TABLE RENAME COLUMN is not supported for table '{full_table_identifier}'. "
+                        f"This table was created as a v1 table with a data source that doesn't support column renaming. "
+                        f"To enable this operation, set 'snowpark.connect.enable_snowflake_extension_behavior' to 'true'."
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
+
                 column_obj = logical_plan.column()
                 old_column_name = ".".join(
                     spark_to_sf_single_id(str(part), is_column=True)
@@ -756,7 +1395,7 @@ def map_sql_to_pandas_df(
                     case_insensitive_name = next(
                         (
                             f.name
-                            for f in session.table(table_name).schema.fields
+                            for f in session.table(full_table_identifier).schema.fields
                             if f.name.lower() == old_column_name.lower()
                         ),
                         None,
@@ -768,7 +1407,7 @@ def map_sql_to_pandas_df(
                 )
 
                 # Pass through to Snowflake
-                snowflake_sql = f"ALTER TABLE {table_name} RENAME COLUMN {old_column_name} TO {new_column_name}"
+                snowflake_sql = f"ALTER TABLE {full_table_identifier} RENAME COLUMN {old_column_name} TO {new_column_name}"
                 session.sql(snowflake_sql).collect()
             case "RenameTable":
                 name = get_relation_identifier_name(logical_plan.child(), True)
@@ -786,30 +1425,31 @@ def map_sql_to_pandas_df(
                             f"ALTER ICEBERG TABLE {name} RENAME TO {new_name}"
                         ).collect()
                     else:
+                        attach_custom_error_code(e, ErrorCodes.INTERNAL_ERROR)
                         raise e
             case "ReplaceTableAsSelect":
                 _create_table_as_select(logical_plan, mode="overwrite")
             case "ResetCommand":
                 key = logical_plan.config().get()
-                unset_config_param(get_session_id(), key, session)
+                unset_config_param(get_spark_session_id(), key, session)
             case "SetCatalogAndNamespace":
                 # TODO: add catalog setting here
                 name = get_relation_identifier_name(logical_plan.child(), True)
-                name = change_default_to_public(name)
                 session.sql(f"USE SCHEMA {name}").collect()
             case "SetCommand":
                 kv_result_tuple = logical_plan.kv().get()
                 key = kv_result_tuple._1()
                 val = kv_result_tuple._2().get()
-                set_config_param(get_session_id(), key, val, session)
+                set_config_param(get_spark_session_id(), key, val, session)
             case "SetNamespaceCommand":
                 name = _spark_to_snowflake(logical_plan.namespace())
-                name = change_default_to_public(name)
                 session.sql(f"USE SCHEMA {name}").collect()
             case "SetNamespaceLocation" | "SetNamespaceProperties":
-                raise SnowparkConnectNotImplementedError(
+                exception = SnowparkConnectNotImplementedError(
                     "Altering databases is not currently supported."
                 )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
             case "ShowCreateTable":
                 # Handle SHOW CREATE TABLE command
                 # Spark: SHOW CREATE TABLE table_name
@@ -831,16 +1471,24 @@ def map_sql_to_pandas_df(
             case "ShowNamespaces":
                 name = get_relation_identifier_name(logical_plan.namespace(), True)
                 if name:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         "'IN' clause is not supported while listing databases"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
                 if logical_plan.pattern().isDefined():
                     # Snowflake SQL requires a "%" pattern.
                     # Snowpark catalog requires a regex and does client-side filtering.
                     # Spark, however, uses a regex-like pattern that treats '*' and '|' differently.
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         "'LIKE' clause is not supported while listing databases"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
                 rows = session.sql("SHOW SCHEMAS").collect()
                 if not rows:
                     rows = None
@@ -913,6 +1561,18 @@ def map_sql_to_pandas_df(
                 if pattern and rows:
                     rows = _filter_tables_by_pattern(rows, pattern)
             case "ShowColumns":
+                name = get_relation_identifier_name_without_uppercasing(
+                    logical_plan.child(), True
+                )
+                stored_temp_view = get_temp_view(name)
+                if stored_temp_view:
+                    return (
+                        SNOWFLAKE_CATALOG._list_columns_from_dataframe_container(
+                            stored_temp_view
+                        ),
+                        "",
+                    )
+
                 # Handle Spark SQL: SHOW COLUMNS IN table_name FROM database_name
                 # Convert to Snowflake SQL: SHOW COLUMNS IN TABLE database_name.table_name
 
@@ -941,9 +1601,13 @@ def map_sql_to_pandas_df(
                             spark_to_sf_single_id(str(db_and_table_name[0])).casefold()
                             != db_name.casefold()
                         ):
-                            raise AnalysisException(
+                            exception = AnalysisException(
                                 f"database name is not matching:{db_name} and {db_and_table_name[0]}"
                             )
+                            attach_custom_error_code(
+                                exception, ErrorCodes.INVALID_OPERATION
+                            )
+                            raise exception
 
                             # Just table name
                     snowflake_cmd = f"SHOW COLUMNS IN TABLE {table_name}"
@@ -981,6 +1645,51 @@ def map_sql_to_pandas_df(
                         return pandas.DataFrame({"": [""]}), ""
 
                 rows = session.sql(snowflake_sql).collect()
+            case "RefreshTable":
+                table_name_unquoted = ".".join(
+                    str(part)
+                    for part in as_java_list(logical_plan.child().multipartIdentifier())
+                )
+                SNOWFLAKE_CATALOG.refreshTable(table_name_unquoted)
+
+                return pandas.DataFrame({"": [""]}), ""
+            case "RepairTable":
+                # No-Op: Snowflake doesn't have explicit partitions to repair.
+                table_relation = logical_plan.child()
+                db_and_table_name = as_java_list(table_relation.multipartIdentifier())
+                multi_part_len = len(db_and_table_name)
+
+                if multi_part_len == 1:
+                    table_name = db_and_table_name[0]
+                    db_name = None
+                    full_table_name = table_name
+                else:
+                    db_name = db_and_table_name[0]
+                    table_name = db_and_table_name[1]
+                    full_table_name = db_name + "." + table_name
+
+                df = SNOWFLAKE_CATALOG.tableExists(table_name, db_name)
+
+                table_exist = df.iloc[0, 0]
+
+                if not table_exist:
+                    exception = AnalysisException(
+                        f"[TABLE_OR_VIEW_NOT_FOUND] Table not found `{full_table_name}`."
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+                    raise exception
+
+                return pandas.DataFrame({"": [""]}), ""
+            case "UnresolvedWith":
+                child = logical_plan.child()
+                child_class = str(child.getClass().getSimpleName())
+                match child_class:
+                    case "InsertIntoStatement":
+                        with _with_cte_scope(logical_plan.cteRelations()):
+                            _insert_into_table(child, get_or_create_snowpark_session())
+                    case _:
+                        execute_logical_plan(logical_plan)
+                        return None, None
             case _:
                 execute_logical_plan(logical_plan)
                 return None, None
@@ -1001,6 +1710,27 @@ def get_sql_passthrough() -> bool:
     return get_boolean_session_config_param("snowpark.connect.sql.passthrough")
 
 
+def is_valid_passthrough_sql(sql_stmt: str) -> Tuple[bool, str]:
+    """
+    Checks if :param sql_stmt: should be executed as SQL pass-through. SQL pass-through can be detected in 1 of 2 ways:
+    1) Either Spark config parameter "snowpark.connect.sql.passthrough" is set (legacy mode, to be deprecated)
+    2) If :param sql_stmt: is created through SnowflakeSession and has correct marker + checksum
+    """
+    if get_sql_passthrough():
+        # legacy style pass-through, sql_stmt should be a whole, valid SQL statement
+        return True, sql_stmt
+
+    # check for new style, SnowflakeSession based SQL pass-through
+    sql_parts = sql_stmt.split(" ", 2)
+    if len(sql_parts) == 3:
+        marker, checksum, sql = sql_parts
+        if marker == SQL_PASS_THROUGH_MARKER and checksum == calculate_checksum(sql):
+            return True, sql
+
+    # Not a SQL pass-through
+    return False, sql_stmt
+
+
 def change_default_to_public(name: str) -> str:
     """
     Change the namespace to PUBLIC when given name is DEFAULT
@@ -1015,6 +1745,76 @@ def change_default_to_public(name: str) -> str:
     return name
 
 
+def _preprocess_identifier_calls(sql_query: str) -> str:
+    """
+    Pre-process SQL query to resolve IDENTIFIER() calls before Spark parsing.
+
+    Transforms: IDENTIFIER('abs')(c2) -> abs(c2)
+    Transforms: IDENTIFIER('COAL' || 'ESCE')(NULL, 1) -> COALESCE(NULL, 1)
+
+    This preserves all function arguments in their original positions, eliminating
+    the need to reconstruct them at the expression level.
+    """
+    import re
+
+    # Pattern to match IDENTIFIER(...) followed by optional function call arguments
+    # This captures both the identifier expression and any trailing arguments
+    # Note: We need to be careful about whitespace preservation
+    identifier_pattern = r"IDENTIFIER\s*\(\s*([^)]+)\s*\)(\s*)(\([^)]*\))?"
+
+    def resolve_identifier_match(match):
+        identifier_expr_str = match.group(1).strip()
+        whitespace = match.group(2) if match.group(2) else ""
+        function_args = match.group(3) if match.group(3) else ""
+
+        try:
+            # Handle string concatenation FIRST: IDENTIFIER('COAL' || 'ESCE')
+            # (Must check this before simple strings since it also starts/ends with quotes)
+            if "||" in identifier_expr_str:
+                # Parse basic string concatenation with proper quote handling
+                parts = []
+                split_parts = identifier_expr_str.split("||")
+                for part in split_parts:
+                    part = part.strip()
+                    if part.startswith("'") and part.endswith("'"):
+                        unquoted = part[1:-1]  # Remove quotes from each part
+                        parts.append(unquoted)
+                    else:
+                        # Non-string parts - return original for safety
+                        return match.group(0)
+                resolved_name = "".join(parts)  # Concatenate the unquoted parts
+
+            # Handle simple string literals: IDENTIFIER('abs')
+            elif identifier_expr_str.startswith("'") and identifier_expr_str.endswith(
+                "'"
+            ):
+                resolved_name = identifier_expr_str[1:-1]  # Remove quotes
+
+            else:
+                # Complex expressions not supported yet - return original
+                return match.group(0)
+
+            # Return resolved function call with preserved arguments and whitespace
+            if function_args:
+                # Function call case: IDENTIFIER('abs')(c1) -> abs(c1)
+                result = f"{resolved_name}{function_args}"
+            else:
+                # Column reference case: IDENTIFIER('c1') FROM -> c1 FROM (preserve whitespace)
+                result = f"{resolved_name}{whitespace}"
+            return result
+
+        except Exception:
+            # Return original to avoid breaking the query
+            return match.group(0)
+
+    # Apply the transformation
+    processed_query = re.sub(
+        identifier_pattern, resolve_identifier_match, sql_query, flags=re.IGNORECASE
+    )
+
+    return processed_query
+
+
 def map_sql(
     rel: relation_proto.Relation,
 ) -> DataFrameContainer:
@@ -1026,10 +1826,15 @@ def map_sql(
     In passthough mode as True, SAS calls session.sql() and not calling Spark Parser.
     This is to mitigate any issue not covered by spark logical plan to protobuf conversion.
     """
-    snowpark_connect_sql_passthrough = get_sql_passthrough()
+    snowpark_connect_sql_passthrough, sql_stmt = is_valid_passthrough_sql(rel.sql.query)
 
     if not snowpark_connect_sql_passthrough:
-        logical_plan = sql_parser().parseQuery(rel.sql.query)
+        # Changed from parseQuery to parsePlan as Spark parseQuery() call generating wrong logical plan for
+        # query like this: SELECT cast('3.4' as decimal(38, 18)) UNION SELECT 'foo'
+        # As such other place in this file we use parsePlan.
+        # Main difference between parsePlan() and parseQuery() is, parsePlan() can be called for any SQL statement, while
+        # parseQuery() can only be called for query statements.
+        logical_plan = sql_parser().parsePlan(sql_stmt)
 
         parsed_pos_args = parse_pos_args(logical_plan, rel.sql.pos_args)
         set_sql_args(rel.sql.args, parsed_pos_args)
@@ -1037,7 +1842,7 @@ def map_sql(
         return execute_logical_plan(logical_plan)
     else:
         session = snowpark.Session.get_active_session()
-        sql_df = session.sql(rel.sql.query)
+        sql_df = session.sql(sql_stmt)
         columns = sql_df.columns
         return DataFrameContainer.create_with_column_mapping(
             dataframe=sql_df,
@@ -1112,7 +1917,19 @@ def map_logical_plan_relation(
                     attr_parts = as_java_list(expr.nameParts())
                     if len(attr_parts) == 1:
                         attr_name = str(attr_parts[0])
-                        return alias_map.get(attr_name, expr)
+                        if attr_name in alias_map:
+                            # Check if the alias references an aggregate function
+                            # If so, don't substitute because you can't GROUP BY an aggregate
+                            aliased_expr = alias_map[attr_name]
+                            aliased_expr_class = str(
+                                aliased_expr.getClass().getSimpleName()
+                            )
+                            if aliased_expr_class == "UnresolvedFunction":
+                                func_name = str(aliased_expr.nameParts().head())
+                                if is_aggregate_function(func_name):
+                                    return expr
+                            return aliased_expr
+                        return expr
 
                     return expr
 
@@ -1129,9 +1946,13 @@ def map_logical_plan_relation(
                             group_type = snowflake_proto.Aggregate.GROUP_TYPE_CUBE
                         case "GroupingSets":
                             if not exp.userGivenGroupByExprs().isEmpty():
-                                raise SnowparkConnectNotImplementedError(
+                                exception = SnowparkConnectNotImplementedError(
                                     "User-defined group by expressions are not supported"
                                 )
+                                attach_custom_error_code(
+                                    exception, ErrorCodes.UNSUPPORTED_OPERATION
+                                )
+                                raise exception
                             group_type = (
                                 snowflake_proto.Aggregate.GROUP_TYPE_GROUPING_SETS
                             )
@@ -1147,9 +1968,13 @@ def map_logical_plan_relation(
 
                 if group_type != snowflake_proto.Aggregate.GROUP_TYPE_GROUPBY:
                     if len(group_expression_list) != 1:
-                        raise SnowparkConnectNotImplementedError(
+                        exception = SnowparkConnectNotImplementedError(
                             "Multiple grouping expressions are not supported"
                         )
+                        attach_custom_error_code(
+                            exception, ErrorCodes.UNSUPPORTED_OPERATION
+                        )
+                        raise exception
                     if group_type == snowflake_proto.Aggregate.GROUP_TYPE_GROUPING_SETS:
                         group_expression_list = []  # TODO: exp.userGivenGroupByExprs()?
                     else:
@@ -1281,38 +2106,89 @@ def map_logical_plan_relation(
         case "Pivot":
             pivot_column = map_logical_plan_expression(rel.pivotColumn())
             session = snowpark.Session.get_active_session()
-            m = ColumnNameMap([], [], None)
+            m = ColumnNameMap([], [])
 
-            pivot_values = [
-                map_logical_plan_expression(e) for e in as_java_list(rel.pivotValues())
-            ]
+            pivot_columns = (
+                [
+                    col
+                    for col in pivot_column.unresolved_function.arguments
+                    if col.HasField("unresolved_attribute")
+                ]
+                if pivot_column.HasField("unresolved_function")
+                else [pivot_column]
+            )
 
-            pivot_literals = []
+            typer = ExpressionTyper.dummy_typer(session)
 
-            for expr_proto in pivot_values:
-                expr = map_single_column_expression(
-                    expr_proto, m, ExpressionTyper.dummy_typer(session)
+            expression_protos: list[expressions_proto.Expression] = []
+            expressions: list[TypedColumn] = []
+            aliases: list[str] = []
+
+            for pivot_value in as_java_list(rel.pivotValues()):
+                expr_proto = map_logical_plan_expression(pivot_value)
+                alias, expr = map_single_column_expression(expr_proto, m, typer)
+
+                expression_protos.append(expr_proto)
+                expressions.append(expr)
+                aliases.append(alias)
+
+            resolved_pivot_values_row = (
+                session.range(1)
+                .select(*[expr.col for expr in expressions])
+                .collect()[0]
+            )
+            resolved_pivot_values = [value for value in resolved_pivot_values_row]
+
+            pivot_values = []
+            for expr_proto, expr, alias, value in zip(
+                expression_protos, expressions, aliases, resolved_pivot_values
+            ):
+                literals_proto = (
+                    [
+                        _map_value_to_literal_proto(v, expr.typ.fields[i].datatype)
+                        for i, v in enumerate(value)
+                    ]
+                    if isinstance(expr.typ, snowpark.types.StructType)
+                    else [_map_value_to_literal_proto(value, expr.typ)]
                 )
-                value = session.range(1).select(expr[1].col).collect()[0][0]
-                pivot_literals.append(
-                    expressions_proto.Expression.Literal(string=str(value))
+
+                if len(pivot_columns) != len(literals_proto):
+                    raise AnalysisException(
+                        f"[PIVOT_VALUE_DATA_TYPE_MISMATCH] Number of pivot columns ({len(pivot_columns)}) does not match number of values ({len(literals_proto)})"
+                    )
+
+                current_pivot_value_proto = (
+                    snowflake_proto.Aggregate.Pivot.PivotValue(
+                        values=literals_proto, alias=alias
+                    )
+                    if expr_proto.HasField("alias")
+                    else snowflake_proto.Aggregate.Pivot.PivotValue(
+                        values=literals_proto
+                    )
                 )
 
+                pivot_values.append(current_pivot_value_proto)
+
             aggregate_expressions = [
                 map_logical_plan_expression(e) for e in as_java_list(rel.aggregates())
             ]
 
-            proto = relation_proto.Relation(
-                aggregate=relation_proto.Aggregate(
-                    input=map_logical_plan_relation(rel.child()),
-                    aggregate_expressions=aggregate_expressions,
-                    group_type=relation_proto.Aggregate.GroupType.GROUP_TYPE_PIVOT,
-                    pivot=relation_proto.Aggregate.Pivot(
-                        col=pivot_column, values=pivot_literals
-                    ),
+            any_proto = Any()
+            any_proto.Pack(
+                snowflake_proto.Extension(
+                    aggregate=snowflake_proto.Aggregate(
+                        input=map_logical_plan_relation(rel.child()),
+                        group_type=relation_proto.Aggregate.GroupType.GROUP_TYPE_PIVOT,
+                        aggregate_expressions=aggregate_expressions,
+                        having_condition=_having_condition.get(),
+                        pivot=snowflake_proto.Aggregate.Pivot(
+                            pivot_columns=pivot_columns,
+                            pivot_values=pivot_values,
+                        ),
+                    )
                 )
             )
-
+            proto = relation_proto.Relation(extension=any_proto)
         case "PlanWithUnresolvedIdentifier":
             expr_proto = map_logical_plan_expression(rel.identifierExpr())
             session = snowpark.Session.get_active_session()
@@ -1343,23 +2219,119 @@ def map_logical_plan_relation(
                 )
             )
         case "Sort":
+            # Process the input first
+            input_proto = map_logical_plan_relation(rel.child())
+
+            # Check if child is a Project - if so, build an alias map for ORDER BY resolution
+            # This handles: SELECT o.date AS order_date ... ORDER BY o.date
+            child_class = str(rel.child().getClass().getSimpleName())
+            alias_map = {}
+
+            if child_class == "Project":
+                # Extract aliases from SELECT clause
+                for proj_expr in list(as_java_list(rel.child().projectList())):
+                    if str(proj_expr.getClass().getSimpleName()) == "Alias":
+                        alias_name = str(proj_expr.name())
+                        child_expr = proj_expr.child()
+
+                        # Store mapping from original expression to alias name
+                        # Use string representation for matching
+                        expr_str = str(child_expr)
+                        alias_map[expr_str] = alias_name
+
+                        # Also handle UnresolvedAttribute specifically to get the qualified name
+                        if (
+                            str(child_expr.getClass().getSimpleName())
+                            == "UnresolvedAttribute"
+                        ):
+                            # Get the qualified name like "o.date"
+                            name_parts = list(as_java_list(child_expr.nameParts()))
+                            qualified_name = ".".join(str(part) for part in name_parts)
+                            if qualified_name not in alias_map:
+                                alias_map[qualified_name] = alias_name
+
+            # Process ORDER BY expressions, substituting aliases where needed
+            order_list = []
+            for order_expr in as_java_list(rel.order()):
+                # Get the child expression from the SortOrder
+                child_expr = order_expr.child()
+                expr_class = str(child_expr.getClass().getSimpleName())
+
+                # Check if this expression matches any aliased expression
+                expr_str = str(child_expr)
+                substituted = False
+
+                if expr_str in alias_map:
+                    # Found a match - substitute with alias reference
+                    alias_name = alias_map[expr_str]
+                    # Create new UnresolvedAttribute for the alias
+                    UnresolvedAttribute = jpype.JClass(
+                        "org.apache.spark.sql.catalyst.analysis.UnresolvedAttribute"
+                    )
+                    new_attr = UnresolvedAttribute.quoted(alias_name)
+
+                    # Create new SortOrder with substituted expression
+                    SortOrder = jpype.JClass(
+                        "org.apache.spark.sql.catalyst.expressions.SortOrder"
+                    )
+                    new_order = SortOrder(
+                        new_attr,
+                        order_expr.direction(),
+                        order_expr.nullOrdering(),
+                        order_expr.sameOrderExpressions(),
+                    )
+                    order_list.append(map_logical_plan_expression(new_order).sort_order)
+                    substituted = True
+                elif expr_class == "UnresolvedAttribute":
+                    # Try matching on qualified name
+                    name_parts = list(as_java_list(child_expr.nameParts()))
+                    qualified_name = ".".join(str(part) for part in name_parts)
+                    if qualified_name in alias_map:
+                        alias_name = alias_map[qualified_name]
+                        UnresolvedAttribute = jpype.JClass(
+                            "org.apache.spark.sql.catalyst.analysis.UnresolvedAttribute"
+                        )
+                        new_attr = UnresolvedAttribute.quoted(alias_name)
+
+                        SortOrder = jpype.JClass(
+                            "org.apache.spark.sql.catalyst.expressions.SortOrder"
+                        )
+                        new_order = SortOrder(
+                            new_attr,
+                            order_expr.direction(),
+                            order_expr.nullOrdering(),
+                            order_expr.sameOrderExpressions(),
+                        )
+                        order_list.append(
+                            map_logical_plan_expression(new_order).sort_order
+                        )
+                        substituted = True
+
+                if not substituted:
+                    # No substitution needed - use original
+                    order_list.append(
+                        map_logical_plan_expression(order_expr).sort_order
+                    )
+
             proto = relation_proto.Relation(
                 sort=relation_proto.Sort(
-                    input=map_logical_plan_relation(rel.child()),
-                    order=[
-                        map_logical_plan_expression(e).sort_order
-                        for e in as_java_list(rel.order())
-                    ],
+                    input=input_proto,
+                    order=order_list,
                 )
             )
         case "SubqueryAlias":
             alias = str(rel.alias())
-            proto = relation_proto.Relation(
-                subquery_alias=relation_proto.SubqueryAlias(
-                    input=map_logical_plan_relation(rel.child()),
-                    alias=alias,
-                )
+            # If the child is an UnresolvedRelation, we want to preserve the original plan id and save only aliased one
+            process_aliased_relation = (
+                str(rel.child().getClass().getSimpleName()) == "UnresolvedRelation"
             )
+            with push_processing_aliased_relation_scope(process_aliased_relation):
+                proto = relation_proto.Relation(
+                    subquery_alias=relation_proto.SubqueryAlias(
+                        input=map_logical_plan_relation(rel.child()),
+                        alias=alias,
+                    )
+                )
             set_sql_plan_name(alias, plan_id)
         case "Union":
             children = as_java_list(rel.children())
@@ -1381,12 +2353,14 @@ def map_logical_plan_relation(
 
             # Check for multi-column UNPIVOT which Snowflake doesn't support
             if len(value_column_names) > 1:
-                raise UnsupportedOperationException(
+                exception = UnsupportedOperationException(
                     f"Multi-column UNPIVOT is not supported. Snowflake SQL does not support unpivoting "
                     f"multiple value columns ({', '.join(value_column_names)}) in a single operation. "
                     f"Workaround: Use separate UNPIVOT operations for each value column and join the results, "
                     f"or restructure your query to unpivot columns individually."
                 )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
 
             values = []
             values_groups = as_java_list(rel.values().get())
@@ -1394,11 +2368,13 @@ def map_logical_plan_relation(
             # Check if we have multi-column groups in the IN clause
             if values_groups and len(as_java_list(values_groups[0])) > 1:
                 group_sizes = [len(as_java_list(group)) for group in values_groups]
-                raise UnsupportedOperationException(
+                exception = UnsupportedOperationException(
                     f"Multi-column UNPIVOT is not supported. Snowflake SQL does not support unpivoting "
                     f"multiple columns together in groups. Found groups with {max(group_sizes)} columns. "
                     f"Workaround: Unpivot each column separately and then join/union the results as needed."
                 )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
 
             for e1 in values_groups:
                 for e in as_java_list(e1):
@@ -1444,9 +2420,11 @@ def map_logical_plan_relation(
             # Store the having condition in context and process the child aggregate
             child_relation = rel.child()
             if str(child_relation.getClass().getSimpleName()) != "Aggregate":
-                raise SnowparkConnectNotImplementedError(
+                exception = SnowparkConnectNotImplementedError(
                     "UnresolvedHaving can only be applied to Aggregate relations"
                 )
+                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+                raise exception
 
             # Store having condition in a context variable for the Aggregate case to pick up
             having_condition = map_logical_plan_expression(rel.havingCondition())
@@ -1509,7 +2487,8 @@ def map_logical_plan_relation(
             )
         case "UnresolvedRelation":
             name = str(rel.name())
-            set_sql_plan_name(name, plan_id)
+            if not get_is_processing_aliased_relation():
+                set_sql_plan_name(name, plan_id)
 
             cte_proto = _ctes.get().get(name)
             if cte_proto is not None:
@@ -1530,10 +2509,16 @@ def map_logical_plan_relation(
                     )
 
                     # Re-evaluate the CTE definition with a fresh plan_id
-                    fresh_plan_id = gen_sql_plan_id()
-                    fresh_cte_proto = map_logical_plan_relation(
-                        cte_definition, fresh_plan_id
-                    )
+                    # Clear HAVING condition to prevent leakage from outer CTEs
+                    saved_having = _having_condition.get()
+                    _having_condition.set(None)
+                    try:
+                        fresh_plan_id = gen_sql_plan_id()
+                        fresh_cte_proto = map_logical_plan_relation(
+                            cte_definition, fresh_plan_id
+                        )
+                    finally:
+                        _having_condition.set(saved_having)
 
                     # Use SubqueryColumnAliases to ensure consistent column names across CTE references
                     # This is crucial for CTEs that reference other CTEs
@@ -1612,14 +2597,35 @@ def map_logical_plan_relation(
                         .collect()[0]
                     )
 
+                    def _parse_value(argument, place):
+                        if isinstance(argument, (Decimal, float)):
+                            return int(argument)
+                        elif isinstance(argument, str):
+                            try:
+                                value = float(argument)
+                                if value < 0:
+                                    return math.ceil(value)
+                                return math.floor(float(argument))
+                            except ValueError:
+                                raise AnalysisException(
+                                    f'[UNEXPECTED_INPUT_TYPE] Parameter {place} of function `range` requires the "BIGINT" type, however "{argument}" has the type "STRING"'
+                                )
+                        return argument
+
                     start, step = 0, 1
                     match args:
                         case [_]:
                             [end] = args
+                            end = _parse_value(end, 1)
                         case [_, _]:
                             [start, end] = args
+                            start = _parse_value(start, 1)
+                            end = _parse_value(end, 2)
                         case [_, _, _]:
                             [start, end, step] = args
+                            start = _parse_value(start, 1)
+                            end = _parse_value(end, 2)
+                            step = _parse_value(step, 3)
 
                     proto = relation_proto.Relation(
                         range=relation_proto.Range(
@@ -1688,16 +2694,7 @@ def map_logical_plan_relation(
                         ),
                     )
         case "UnresolvedWith":
-            with _push_cte_scope():
-                for cte in as_java_list(rel.cteRelations()):
-                    name = str(cte._1())
-                    # Store the original CTE definition for re-evaluation
-                    _cte_definitions.get()[name] = cte._2()
-                    # Process CTE definition with a unique plan_id to ensure proper column naming
-                    cte_plan_id = gen_sql_plan_id()
-                    cte_proto = map_logical_plan_relation(cte._2(), cte_plan_id)
-                    _ctes.get()[name] = cte_proto
-
+            with _with_cte_scope(rel.cteRelations()):
                 proto = map_logical_plan_relation(rel.child())
         case "LateralJoin":
             left = map_logical_plan_relation(rel.left())
@@ -1719,41 +2716,16 @@ def map_logical_plan_relation(
                     _window_specs.get()[key] = window_spec
                 proto = map_logical_plan_relation(rel.child())
         case "Generate":
-            # Generate creates a nested Project relation (see lines 1785-1790) without
-            # setting its plan_id field. When this Project is later processed by map_project
-            # (map_column_ops.py), it uses rel.common.plan_id which defaults to 0 for unset
-            # protobuf fields. This means all columns from the Generate operation (both exploded
-            # columns and passthrough columns) will have plan_id=0 in their names.
-            #
-            # If Generate's child is a SubqueryAlias whose inner relation was processed
-            # with a non-zero plan_id, there will be a mismatch between:
-            # - The columns referenced in the Project (expecting plan_id from SubqueryAlias's child)
-            # - The actual column names created by Generate's Project (using plan_id=0)
-
-            # Therefore, when Generate has a SubqueryAlias child, we explicitly process the inner
-            # relation with plan_id=0 to match what Generate's Project will use. This only applies when
-            # the immediate child of Generate is a SubqueryAlias and preserves existing registrations (like CTEs),
-            # so it won't affect other patterns.
-
             child_class = str(rel.child().getClass().getSimpleName())
 
             if child_class == "SubqueryAlias":
                 alias = str(rel.child().alias())
 
-                # Check if this alias was already registered during initial SQL parsing
                 existing_plan_id = get_sql_plan(alias)
 
-                if existing_plan_id is not None:
-                    # Use the existing plan_id to maintain consistency with prior registration
-                    used_plan_id = existing_plan_id
-                else:
-                    # Use plan_id=0 to match what the nested Project will use (protobuf default)
-                    used_plan_id = 0
-                    set_sql_plan_name(alias, used_plan_id)
-
                 # Process the inner child with the determined plan_id
                 inner_child = map_logical_plan_relation(
-                    rel.child().child(), plan_id=used_plan_id
+                    rel.child().child(), plan_id=existing_plan_id
                 )
                 input_relation = relation_proto.Relation(
                     subquery_alias=relation_proto.SubqueryAlias(
@@ -1771,19 +2743,19 @@ def map_logical_plan_relation(
             function_name = rel.generator().name().toString()
             func_arguments = [
                 map_logical_plan_expression(e)
-                for e in as_java_list(rel.generator().children())
+                for e in list(as_java_list(rel.generator().children()))
             ]
             unresolved_fun_proto = expressions_proto.Expression.UnresolvedFunction(
                 function_name=function_name, arguments=func_arguments
             )
 
-            aliased_proto = unresolved_fun_proto
+            aliased_proto = expressions_proto.Expression(
+                unresolved_function=unresolved_fun_proto,
+            )
             if generator_output_list.size() > 0:
                 aliased_proto = expressions_proto.Expression(
                     alias=expressions_proto.Expression.Alias(
-                        expr=expressions_proto.Expression(
-                            unresolved_function=unresolved_fun_proto,
-                        ),
+                        expr=aliased_proto,
                         name=[attribute.name() for attribute in generator_output_list],
                     )
                 )
@@ -1837,28 +2809,67 @@ def map_logical_plan_relation(
                 )
             proto = generator_dataframe_proto
         case other:
-            raise SnowparkConnectNotImplementedError(f"Unimplemented relation: {other}")
+            exception = SnowparkConnectNotImplementedError(
+                f"Unimplemented relation: {other}"
+            )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
 
     proto.common.plan_id = plan_id
 
     return proto
 
 
+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 _create_temp_view_name(parts) -> str:
+    return ".".join(
+        quote_name_without_upper_casing(str(part)) for part in as_java_list(parts)
+    )
+
+
+def get_relation_identifier_name_without_uppercasing(
+    name_obj, is_multi_part: bool = False
+) -> str:
+    if name_obj.getClass().getSimpleName() in (
+        "PlanWithUnresolvedIdentifier",
+        "ExpressionWithUnresolvedIdentifier",
+    ):
+        return _get_relation_identifier(name_obj)
+    elif is_multi_part:
+        try:
+            # Try multipartIdentifier first for full catalog.database.table
+            return _create_temp_view_name(name_obj.multipartIdentifier())
+        except AttributeError:
+            # Fallback to nameParts if multipartIdentifier not available
+            return _create_temp_view_name(name_obj.nameParts())
+    else:
+        return _create_temp_view_name(name_obj.nameParts())
+
+
 def get_relation_identifier_name(name_obj, is_multi_part: bool = False) -> str:
-    if name_obj.getClass().getSimpleName() == "PlanWithUnresolvedIdentifier":
-        # IDENTIFIER(<table_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]
-        )
+    if name_obj.getClass().getSimpleName() in (
+        "PlanWithUnresolvedIdentifier",
+        "ExpressionWithUnresolvedIdentifier",
+    ):
+        return _get_relation_identifier(name_obj)
     else:
         if is_multi_part:
-            name = _spark_to_snowflake(name_obj.multipartIdentifier())
+            try:
+                # Try multipartIdentifier first for full catalog.database.table
+                name = _spark_to_snowflake(name_obj.multipartIdentifier())
+            except AttributeError:
+                # Fallback to nameParts if multipartIdentifier not available
+                name = _spark_to_snowflake(name_obj.nameParts())
         else:
             name = _spark_to_snowflake(name_obj.nameParts())