snowpark-connect 0.20.2__py3-none-any.whl

snowflake/snowpark_connect/relation/map_join.py

@@ -0,0 +1,341 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from functools import reduce
+
+import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+
+import snowflake.snowpark.functions as snowpark_fn
+from snowflake import snowpark
+from snowflake.snowpark_connect.column_name_handler import (
+    ColumnNameMap,
+    JoinColumnNameMap,
+    set_schema_getter,
+    with_column_map,
+)
+from snowflake.snowpark_connect.config import global_config
+from snowflake.snowpark_connect.constants import COLUMN_METADATA_COLLISION_KEY
+from snowflake.snowpark_connect.error.error_utils import SparkException
+from snowflake.snowpark_connect.expression.map_expression import (
+    map_single_column_expression,
+)
+from snowflake.snowpark_connect.expression.typer import JoinExpressionTyper
+from snowflake.snowpark_connect.relation.map_relation import (
+    NATURAL_JOIN_TYPE_BASE,
+    map_relation,
+)
+from snowflake.snowpark_connect.utils.context import (
+    push_evaluating_join_condition,
+    push_sql_scope,
+    set_plan_id_map,
+    set_sql_plan_name,
+)
+from snowflake.snowpark_connect.utils.telemetry import (
+    SnowparkConnectNotImplementedError,
+)
+
+USING_COLUMN_NOT_FOUND_ERROR = "[UNRESOLVED_USING_COLUMN_FOR_JOIN] USING column `{0}` not found on the {1} side of the join. The {1}-side columns: {2}"
+
+
+def map_join(rel: relation_proto.Relation) -> snowpark.DataFrame:
+    left_input: snowpark.DataFrame = map_relation(rel.join.left)
+    right_input: snowpark.DataFrame = map_relation(rel.join.right)
+    is_natural_join = rel.join.join_type >= NATURAL_JOIN_TYPE_BASE
+    using_columns = rel.join.using_columns
+    if is_natural_join:
+        rel.join.join_type -= NATURAL_JOIN_TYPE_BASE
+        left_spark_columns = left_input._column_map.get_spark_columns()
+        right_spark_columns = right_input._column_map.get_spark_columns()
+        common_spark_columns = [
+            x for x in left_spark_columns if x in right_spark_columns
+        ]
+        using_columns = common_spark_columns
+
+    match rel.join.join_type:
+        case relation_proto.Join.JOIN_TYPE_UNSPECIFIED:
+            # TODO: Understand what UNSPECIFIED Join type is
+            raise SnowparkConnectNotImplementedError("Unspecified Join Type")
+        case relation_proto.Join.JOIN_TYPE_INNER:
+            join_type = "inner"
+        case relation_proto.Join.JOIN_TYPE_FULL_OUTER:
+            join_type = "full_outer"
+        case relation_proto.Join.JOIN_TYPE_LEFT_OUTER:
+            join_type = "left"
+        case relation_proto.Join.JOIN_TYPE_RIGHT_OUTER:
+            join_type = "right"
+        case relation_proto.Join.JOIN_TYPE_LEFT_ANTI:
+            join_type = "leftanti"
+        case relation_proto.Join.JOIN_TYPE_LEFT_SEMI:
+            join_type = "leftsemi"
+        case relation_proto.Join.JOIN_TYPE_CROSS:
+            join_type = "cross"
+        case other:
+            raise SnowparkConnectNotImplementedError(f"Other Join Type: {other}")
+
+    # This handles case sensitivity for using_columns
+    case_corrected_right_columns: list[str] = []
+
+    if rel.join.HasField("join_condition"):
+        assert not using_columns
+
+        left_columns = list(left_input._column_map.spark_to_col.keys())
+        right_columns = list(right_input._column_map.spark_to_col.keys())
+
+        # All PySpark join types are in the format of JOIN_TYPE_XXX.
+        # We remove the first 10 characters (JOIN_TYPE_) and replace all underscores with spaces to match the exception.
+        pyspark_join_type = relation_proto.Join.JoinType.Name(rel.join.join_type)[
+            10:
+        ].replace("_", " ")
+        with push_sql_scope(), push_evaluating_join_condition(
+            pyspark_join_type, left_columns, right_columns
+        ):
+            if left_input._alias is not None:
+                set_sql_plan_name(left_input._alias, rel.join.left.common.plan_id)
+            if right_input._alias is not None:
+                set_sql_plan_name(right_input._alias, rel.join.right.common.plan_id)
+            _, join_expression = map_single_column_expression(
+                rel.join.join_condition,
+                column_mapping=JoinColumnNameMap(
+                    left_input,
+                    right_input,
+                ),
+                typer=JoinExpressionTyper(left_input, right_input),
+            )
+        result: snowpark.DataFrame = left_input.join(
+            right=right_input,
+            on=join_expression.col,
+            how=join_type,
+            lsuffix="_left",
+            rsuffix="_right",
+        )
+    elif using_columns:
+        if any(
+            left_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                c, allow_non_exists=True, return_first=True
+            )
+            is None
+            for c in using_columns
+        ):
+            import pyspark
+
+            raise pyspark.errors.AnalysisException(
+                USING_COLUMN_NOT_FOUND_ERROR.format(
+                    next(
+                        c
+                        for c in using_columns
+                        if left_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                            c, allow_non_exists=True, return_first=True
+                        )
+                        is None
+                    ),
+                    "left",
+                    left_input._column_map.get_spark_columns(),
+                )
+            )
+        if any(
+            right_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                c, allow_non_exists=True, return_first=True
+            )
+            is None
+            for c in using_columns
+        ):
+            import pyspark
+
+            raise pyspark.errors.AnalysisException(
+                USING_COLUMN_NOT_FOUND_ERROR.format(
+                    next(
+                        c
+                        for c in using_columns
+                        if right_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                            c, allow_non_exists=True, return_first=True
+                        )
+                        is None
+                    ),
+                    "right",
+                    right_input._column_map.get_spark_columns(),
+                )
+            )
+
+        # Round trip the using columns through the column map to get the correct names
+        # in order to support case sensitivity.
+        # TODO: case_corrected_left_columns / case_corrected_right_columns may no longer be required as Snowpark dataframe preserves the column casing now.
+        case_corrected_left_columns = left_input._column_map.get_spark_column_names_from_snowpark_column_names(
+            left_input._column_map.get_snowpark_column_names_from_spark_column_names(
+                list(using_columns), return_first=True
+            )
+        )
+        case_corrected_right_columns = right_input._column_map.get_spark_column_names_from_snowpark_column_names(
+            right_input._column_map.get_snowpark_column_names_from_spark_column_names(
+                list(using_columns), return_first=True
+            )
+        )
+        using_columns = zip(case_corrected_left_columns, case_corrected_right_columns)
+        # We cannot assume that Snowpark will have the same names for left and right columns,
+        # so we convert ["a", "b"] into (left["a"] == right["a"] & left["b"] == right["b"]),
+        # then drop right["a"] and right["b"].
+        snowpark_using_columns = [
+            (
+                left_input[
+                    left_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                        lft, return_first=True
+                    )
+                ],
+                right_input[
+                    right_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                        r, return_first=True
+                    )
+                ],
+            )
+            for lft, r in using_columns
+        ]
+        joined_df = left_input.join(
+            right=right_input,
+            on=reduce(
+                snowpark.Column.__and__,
+                (left == right for left, right in snowpark_using_columns),
+            ),
+            how=join_type,
+        )
+        # For outer joins, we need to preserve join keys from both sides using COALESCE
+        if join_type == "full_outer":
+            coalesced_columns = []
+            columns_to_drop = []
+            for i, (left_col, right_col) in enumerate(snowpark_using_columns):
+                # Use the original user-specified column name to preserve case sensitivity
+                original_column_name = rel.join.using_columns[i]
+                coalesced_col = snowpark_fn.coalesce(left_col, right_col).alias(
+                    original_column_name
+                )
+                coalesced_columns.append(coalesced_col)
+                columns_to_drop.extend([left_col, right_col])
+
+            other_columns = [
+                snowpark_fn.col(col_name)
+                for col_name in joined_df.columns
+                if col_name not in [col.getName() for col in columns_to_drop]
+            ]
+            result = joined_df.select(coalesced_columns + other_columns)
+        else:
+            result = joined_df.drop(*(right for _, right in snowpark_using_columns))
+    else:
+        if join_type != "cross" and not global_config.spark_sql_crossJoin_enabled:
+            raise SparkException.implicit_cartesian_product("inner")
+        result: snowpark.DataFrame = left_input.join(
+            right=right_input,
+            how=join_type,
+        )
+
+    if join_type in ["leftanti", "leftsemi"]:
+        # Join types that only return columns from the left side:
+        # - LEFT SEMI JOIN: Returns left rows that have matches in right table (no right columns)
+        # - LEFT ANTI JOIN: Returns left rows that have NO matches in right table (no right columns)
+        # Both preserve only the columns from the left DataFrame without adding any columns from the right.
+        spark_cols_after_join: list[str] = left_input._column_map.get_spark_columns()
+        qualifiers = left_input._column_map.get_qualifiers()
+    else:
+        # Add Spark columns and plan_ids from left DF
+        spark_cols_after_join: list[str] = list(
+            left_input._column_map.get_spark_columns()
+        ) + [
+            spark_col
+            for i, spark_col in enumerate(right_input._column_map.get_spark_columns())
+            if spark_col not in case_corrected_right_columns
+            or spark_col
+            in right_input._column_map.get_spark_columns()[
+                :i
+            ]  # this is to make sure we only remove the column once
+        ]
+
+        qualifiers = list(left_input._column_map.get_qualifiers()) + [
+            right_input._column_map.get_qualifier_for_spark_column(spark_col)
+            for i, spark_col in enumerate(right_input._column_map.get_spark_columns())
+            if spark_col not in case_corrected_right_columns
+            or spark_col
+            in right_input._column_map.get_spark_columns()[
+                :i
+            ]  # this is to make sure we only remove the column once]
+        ]
+
+    column_metadata = {}
+    if left_input._column_map.column_metadata:
+        column_metadata.update(left_input._column_map.column_metadata)
+
+    if right_input._column_map.column_metadata:
+        for key, value in right_input._column_map.column_metadata.items():
+            if key not in column_metadata:
+                column_metadata[key] = value
+            else:
+                # In case of collision, use snowpark's column's expr_id as prefix.
+                # this is a temporary solution until SNOW-1926440 is resolved.
+                try:
+                    snowpark_name = right_input._column_map.get_snowpark_column_name_from_spark_column_name(
+                        key
+                    )
+                    expr_id = right_input[snowpark_name]._expression.expr_id
+                    updated_key = COLUMN_METADATA_COLLISION_KEY.format(
+                        expr_id=expr_id, key=snowpark_name
+                    )
+                    column_metadata[updated_key] = value
+                except Exception:
+                    # ignore any errors that happens while fetching the metadata
+                    pass
+
+    result_df = with_column_map(
+        result,
+        spark_cols_after_join,
+        result.columns,
+        column_metadata=column_metadata,
+        column_qualifiers=qualifiers,
+    )
+
+    # Fix for USING join column references with different plan IDs
+    # After a USING join, references to the right dataframe's columns should resolve
+    # to the result dataframe that contains the merged columns
+    if (
+        using_columns
+        and rel.join.right.HasField("common")
+        and rel.join.right.common.HasField("plan_id")
+    ):
+        right_plan_id = rel.join.right.common.plan_id
+        set_plan_id_map(right_plan_id, result_df)
+
+    # For FULL OUTER joins, we also need to map the left dataframe's plan_id
+    # since both columns are replaced with a coalesced column
+    if (
+        using_columns
+        and join_type == "full_outer"
+        and rel.join.left.HasField("common")
+        and rel.join.left.common.HasField("plan_id")
+    ):
+        left_plan_id = rel.join.left.common.plan_id
+        set_plan_id_map(left_plan_id, result_df)
+
+    if rel.join.using_columns:
+        # When join 'using_columns', the 'join columns' should go first in result DF.
+        idxs_to_shift = [
+            spark_cols_after_join.index(left_col_name)
+            for left_col_name in case_corrected_left_columns
+        ]
+
+        def reorder(lst: list) -> list:
+            to_move = [lst[i] for i in idxs_to_shift]
+            remaining = [el for i, el in enumerate(lst) if i not in idxs_to_shift]
+            return to_move + remaining
+
+        reordered_df = result_df.select(
+            [snowpark_fn.col(c) for c in reorder(result_df.columns)]
+        )
+        reordered_df._column_map = ColumnNameMap(
+            spark_column_names=reorder(result_df._column_map.get_spark_columns()),
+            snowpark_column_names=reorder(result_df._column_map.get_snowpark_columns()),
+            column_metadata=column_metadata,
+            column_qualifiers=reorder(qualifiers),
+        )
+        reordered_df._table_name = result_df._table_name
+        set_schema_getter(
+            reordered_df,
+            lambda: snowpark.types.StructType(reorder(result_df.schema.fields)),
+        )
+        return reordered_df
+    return result_df

snowflake/snowpark_connect/relation/map_local_relation.py

@@ -0,0 +1,326 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import json
+import re
+
+import numpy as np
+import pyarrow as pa
+import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+
+from snowflake import snowpark
+from snowflake.snowpark._internal.analyzer.analyzer_utils import unquote_if_quoted
+from snowflake.snowpark.types import LongType, StructField, StructType
+from snowflake.snowpark_connect import tcm
+from snowflake.snowpark_connect.column_name_handler import (
+    make_column_names_snowpark_compatible,
+    with_column_map,
+)
+from snowflake.snowpark_connect.type_mapping import (
+    map_json_schema_to_snowpark,
+    map_pyarrow_to_snowpark_types,
+    map_simple_types,
+)
+from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
+from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
+from snowflake.snowpark_connect.utils.telemetry import (
+    SnowparkConnectNotImplementedError,
+)
+
+
+def parse_local_relation_schema_string(rel: relation_proto.Relation):
+    # schema_str can be a dict, or just a type string, e.g. INTEGER.
+    schema_str = rel.local_relation.schema
+    assert schema_str
+    schema_dict = json.loads(schema_str)
+
+    column_metadata = {}
+    if isinstance(schema_dict, dict):
+        spark_column_names = [field["name"] for field in schema_dict["fields"]]
+        new_columns = make_column_names_snowpark_compatible(
+            spark_column_names, rel.common.plan_id
+        )
+
+        fields = schema_dict.get("fields", None)
+        if fields is not None:
+            for field, new_name in zip(fields, new_columns):
+                if field.get("metadata") is not None:
+                    column_metadata[field["name"]] = field["metadata"]
+
+                # Capture UDT information for later use
+                field_type = field.get("type")
+                if isinstance(field_type, dict) and field_type.get("type") == "udt":
+                    udt_info = {
+                        "__udt_info__": {
+                            "pyClass": field_type.get("pyClass"),
+                            "class": field_type.get("class"),
+                            "sqlType": field_type.get("sqlType"),
+                            "serializedClass": field_type.get("serializedClass"),
+                        }
+                    }
+                    logger.debug(
+                        f"Found UDT field: {field['name']}, storing UDT info: {udt_info}"
+                    )
+
+                    # Merge with existing metadata or create new
+                    if field["name"] in column_metadata:
+                        column_metadata[field["name"]].update(udt_info)
+                    else:
+                        column_metadata[field["name"]] = udt_info
+
+                field["name"] = new_name
+            schema_dict["fields"] = fields
+
+        snowpark_schema = map_json_schema_to_snowpark(
+            schema_dict, quote_struct_fields_names=False
+        )
+    else:
+        # the schema_dict is just a type string without field name.
+        spark_column_names = [
+            "value"
+        ]  # give a default name "value" when no name is provided
+        new_columns = make_column_names_snowpark_compatible(
+            spark_column_names, rel.common.plan_id
+        )
+        snowpark_type = map_simple_types(
+            schema_dict
+        )  # schema_dict should be a simple type string, like "STRING"
+
+        snowpark_schema = snowpark.types.StructType(
+            [
+                snowpark.types.StructField(
+                    new_columns[0], snowpark_type, _is_column=False
+                ),
+            ]
+        )
+    return snowpark_schema, spark_column_names, new_columns, column_metadata
+
+
+def map_pylist_cell_to_python_object(cell, type: pa.lib.DataType):
+    """
+    Pylist means python list, which comes from pyarrow column.to_pylist(). Pylist is preferred over pandas_df in the
+    conversion from pyarrow table to snowpark_df because it keeps more accurate information. E.g., NaN and None are
+    untouched in pylist_df, but are both NaN in pandas_df. Though to_pylist may have lower performance when data size is
+    large, map_local_relation usually applies to small data size.
+    """
+    match type:
+        case struct_type if cell is not None and isinstance(type, pa.lib.StructType):
+            if isinstance(cell, dict):
+                # Handle struct types by recursively processing each field
+                # Example:
+                #   Input:  {'a': 1, 'b': [1, 2], 'c': [('k1', 'v1'), ('k2', 'v2')]}
+                #   Output: {'a': 1, 'b': [1, 2], 'c': {'k1': 'v1', 'k2': 'v2'}}
+                # where field 'c' has MapType and gets converted from list to dict.
+                return {
+                    field.name: map_pylist_cell_to_python_object(
+                        cell[field.name], field.type
+                    )
+                    for field in struct_type
+                }
+            else:
+                # If cell is not a dict (unexpected for struct), return as-is
+                return cell
+        case list_type if cell is not None and isinstance(type, pa.lib.ListType):
+            return [
+                map_pylist_cell_to_python_object(obj, list_type.value_type)
+                for obj in cell
+            ]
+        case map_type if (
+            cell is not None
+            and isinstance(type, pa.lib.MapType)
+            and all(isinstance(obj, tuple) and len(obj) == 2 for obj in cell)
+        ):
+            # the MapType in arrow becomes list in pylist_df,
+            # e.g. {"Car": "Honda", "Bike": "Yamaha"} --> [("Car", "Honda"), ("Bike", "Yamaha")] , and causes some
+            # trouble in the following snowpark dataframe creation, which expects MapType but pylist_df only provides
+            # list (not dict).
+            return {
+                map_pylist_cell_to_python_object(
+                    k, map_type.key_type
+                ): map_pylist_cell_to_python_object(v, map_type.item_type)
+                for k, v in cell
+            }
+        case _:
+            return cell
+
+
+def map_pandas_cell_to_python_object(cell):
+    match cell:
+        case arr if isinstance(arr, np.ndarray):
+            res = [map_pandas_cell_to_python_object(obj) for obj in cell]
+        case [*_] if all(isinstance(obj, tuple) and len(obj) == 2 for obj in cell):
+            # The conversion from arrow_table to pandas_df loses information. we need to re-think what's the correct way, e.g. skip pandas_df?
+            #
+            # 1. For the MapType in arrow, it becomes list in pandas_df,
+            # e.g. {"Car": "Honda", "Bike": "Yamaha"} --> [("Car", "Honda"), ("Bike", "Yamaha")] , and causes some
+            # trouble in the following snowpark dataframe creation, which expects MapType but pandas_df only provides
+            # list (not dict).
+            #
+            # 2. For null in arrow, it becomes nan in pandas_df
+
+            # pyspark MapType becomes a list of tuples with two elements each. Other pyspark type doesn't seem to use list, e.g. ArrayType becomes np.ndarray
+            res = {
+                map_pandas_cell_to_python_object(k): map_pandas_cell_to_python_object(v)
+                for k, v in cell
+            }
+        case _:
+            # Snowpark doesn't accept numpy generic type, e.g. numpy.int32
+            res = cell.item() if isinstance(cell, np.generic) else cell
+    # when NaN (NaN != NaN), res = None, cause Snowpark doesn't support NaN in Row objects
+    return res if res == res else None
+
+
+def map_local_relation(rel: relation_proto.Relation) -> snowpark.DataFrame:
+    if rel.local_relation.HasField("data"):
+        data = pa.BufferReader(rel.local_relation.data)
+        with pa.ipc.open_stream(data) as reader:
+            batches = [batch for batch in reader]
+            table = pa.Table.from_batches(batches)
+        session = get_or_create_snowpark_session()
+        if rel.local_relation.schema == "":
+            snowpark_schema = {}
+            column_metadata = {}
+            spark_column_names = table.column_names
+            new_columns = make_column_names_snowpark_compatible(
+                spark_column_names, rel.common.plan_id
+            )
+            if not all(len(col) == 0 for col in spark_column_names):
+                unquoted_new_columns = [column[1:-1] for column in new_columns]
+                table = table.rename_columns(unquoted_new_columns)
+        else:
+            (
+                snowpark_schema,
+                spark_column_names,
+                new_columns,
+                column_metadata,
+            ) = parse_local_relation_schema_string(rel)
+        # Snowpark ignores the schema when you pass in a pandas DataFrame, so
+        # unfortunately we have to convert it to a list of tuples and pass the schema
+        # so that Snowpark respects this schema. This is particularly problematic for
+        # array type columns, which always because variants due to the conversion from
+        # pandas "object" dtype.
+        if all(len(col) == 0 for col in table.column_names):
+            # Only create the pandas dataframe for empty dataframe cases.
+            pandas_df = table.to_pandas()
+            snowpark_df: snowpark.DataFrame = session.create_dataframe(pandas_df)
+            return with_column_map(
+                snowpark_df,
+                spark_column_names,
+                snowpark_column_names=new_columns,
+                column_metadata=column_metadata,
+            )
+        if snowpark_schema == {}:
+            # If we don't have a provided schema, we'll try to determine the schema using the PyArrow table schema.
+            # This isn't a perfect schema as we can't distinguish between StructTypes and MapTypes. This is because
+            # when we have a numpy array input, map and struct are somewhat synoynmous. This means that we can't tell
+            # them apart. Therefore, we simply cast both of them to VariantType for now until have a better solution.
+            snowpark_schema = StructType(
+                [
+                    StructField(
+                        field.name,
+                        map_pyarrow_to_snowpark_types(field.type),
+                        field.nullable,
+                    )
+                    for field in table.schema
+                ],
+                structured=True,
+            )
+
+        # Special characters in the schema currently break create_dataframe with arrow
+        # https://snowflakecomputing.atlassian.net/browse/SNOW-2199291
+        current_schema = session.get_current_schema()
+        use_pyarrow = (
+            re.match(
+                # See https://docs.snowflake.com/en/sql-reference/identifiers-syntax
+                r"[A-Za-z_][A-Za-z0-9_\$]*",
+                # Schema may be double-quoted.
+                current_schema.strip('"') if current_schema is not None else "",
+            )
+            is not None
+        ) and not tcm.TCM_MODE  # TODO: SNOW-2220726 investigate why use_pyarrow failed in TCM:
+        # TypeError: _create_temp_stage() takes 7 positional arguments but 8 were given
+
+        if use_pyarrow:
+            snowpark_df: snowpark.DataFrame = session.create_dataframe(
+                # Rename the columns to match the Snowpark schema before creating.
+                data=table.rename_columns([unquote_if_quoted(c) for c in new_columns]),
+            )
+
+            # Cast the columns to the correct types based on the schema as create_dataframe will
+            # infer the schema.
+            casted_columns = [
+                snowpark_df[snowpark_df.columns[i]]
+                .cast(field.datatype)
+                .alias(field.name)
+                for i, field in enumerate(snowpark_schema.fields)
+            ]
+
+            snowpark_df = snowpark_df.select(*casted_columns)
+        else:
+            pylist_df = [
+                list(row)
+                for row in zip(*(col.to_pylist() for col in table.itercolumns()))
+            ]
+            data_for_snowpark = [
+                snowpark.Row(
+                    **dict(
+                        zip(
+                            new_columns,
+                            [
+                                (
+                                    map_pylist_cell_to_python_object(
+                                        cell, table.schema.types[i]
+                                    )
+                                )
+                                for i, cell in enumerate(row)
+                            ],
+                        )
+                    )
+                )
+                for row in pylist_df
+            ]
+            snowpark_df: snowpark.DataFrame = session.create_dataframe(
+                data_for_snowpark,
+                snowpark_schema,
+            )
+
+        return with_column_map(
+            snowpark_df,
+            spark_column_names,
+            snowpark_column_names=new_columns,
+            column_metadata=column_metadata,
+            snowpark_column_types=[f.datatype for f in snowpark_schema.fields],
+        )
+    elif rel.local_relation.HasField("schema") and rel.local_relation.schema != "":
+        (
+            snowpark_schema,
+            spark_column_names,
+            new_columns,
+            column_metadata,
+        ) = parse_local_relation_schema_string(rel)
+
+        session = get_or_create_snowpark_session()
+        snowpark_df: snowpark.DataFrame = session.create_dataframe(
+            [],
+            snowpark_schema,
+        )
+        return with_column_map(
+            snowpark_df,
+            spark_column_names,
+            snowpark_column_names=new_columns,
+            column_metadata=column_metadata,
+        )
+    else:
+        raise SnowparkConnectNotImplementedError(
+            "LocalRelation without data & schema is not supported"
+        )
+
+
+def map_range(rel: relation_proto.Relation) -> snowpark.DataFrame:
+    session = get_or_create_snowpark_session()
+    new_columns = make_column_names_snowpark_compatible(["id"], rel.common.plan_id)
+    result = session.range(
+        rel.range.start, rel.range.end, rel.range.step
+    ).with_column_renamed("ID", new_columns[0])
+    return with_column_map(result, ["id"], new_columns, [LongType()])