snowpark-connect 0.20.2__py3-none-any.whl → 0.22.1__py3-none-any.whl

snowflake/snowpark_connect/relation/write/map_write.py

@@ -9,20 +9,30 @@ from pathlib import Path
 import pyspark.sql.connect.proto.base_pb2 as proto_base
 import pyspark.sql.connect.proto.commands_pb2 as commands_proto
 from pyspark.errors.exceptions.base import AnalysisException
-from pyspark.sql.connect.types import StructType
 
 from snowflake import snowpark
 from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     quote_name_without_upper_casing,
     unquote_if_quoted,
 )
+from snowflake.snowpark.exceptions import SnowparkSQLException
 from snowflake.snowpark.functions import col, lit, object_construct
+from snowflake.snowpark.types import (
+    ArrayType,
+    DataType,
+    DateType,
+    MapType,
+    StringType,
+    StructType,
+    TimestampType,
+    _NumericType,
+)
 from snowflake.snowpark_connect.config import (
-    auto_uppercase_ddl,
     global_config,
     sessions_config,
     str_to_bool,
 )
+from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.io_utils import (
     convert_file_prefix_path,
     is_cloud_path,
@@ -32,16 +42,19 @@ from snowflake.snowpark_connect.relation.read.reader_config import CsvWriterConf
 from snowflake.snowpark_connect.relation.stage_locator import get_paths_from_stage
 from snowflake.snowpark_connect.relation.utils import random_string
 from snowflake.snowpark_connect.type_mapping import snowpark_to_iceberg_type
-from snowflake.snowpark_connect.utils.attribute_handling import (
+from snowflake.snowpark_connect.utils.context import get_session_id
+from snowflake.snowpark_connect.utils.identifiers import (
+    spark_to_sf_single_id,
     split_fully_qualified_spark_name,
 )
-from snowflake.snowpark_connect.utils.context import get_session_id
 from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
     telemetry,
 )
 
+_column_order_for_write = "name"
+
 
 # TODO: We will revise/refactor this after changes for all formats are finalized.
 def clean_params(params):
@@ -85,14 +98,9 @@ def get_param_from_options(params, options, source):
         params["format_type_options"]["NULL_IF"] = options["nullValue"]
 
 
-def _spark_to_snowflake_single_id(name: str) -> str:
-    name = quote_name_without_upper_casing(name)
-    return name.upper() if auto_uppercase_ddl() else name
-
-
 def _spark_to_snowflake(multipart_id: str) -> str:
     return ".".join(
-        _spark_to_snowflake_single_id(part)
+        spark_to_sf_single_id(part)
         for part in split_fully_qualified_spark_name(multipart_id)
     )
 
@@ -115,9 +123,8 @@ def map_write(request: proto_base.ExecutePlanRequest):
         case commands_proto.WriteOperation.SaveMode.SAVE_MODE_IGNORE:
             write_mode = "ignore"
 
-    input_df: snowpark.DataFrame = handle_column_names(
-        map_relation(write_op.input), write_op.source
-    )
+    result = map_relation(write_op.input)
+    input_df: snowpark.DataFrame = handle_column_names(result, write_op.source)
     session: snowpark.Session = get_or_create_snowpark_session()
 
     # Snowflake saveAsTable doesn't support format
@@ -198,7 +205,7 @@ def map_write(request: proto_base.ExecutePlanRequest):
             options = dict(write_op.options)
             if write_mode is None:
                 write_mode = "errorifexists"
-            map_write_jdbc(input_df, session, options, write_mode)
+            map_write_jdbc(result, session, options, write_mode)
         case "iceberg":
             table_name = (
                 write_op.path
@@ -207,20 +214,71 @@ def map_write(request: proto_base.ExecutePlanRequest):
             )
             snowpark_table_name = _spark_to_snowflake(table_name)
 
-            if write_mode == "overwrite":
-                if check_snowflake_table_existance(snowpark_table_name, session):
-                    session.sql(f"DELETE FROM {snowpark_table_name}").collect()
-                    write_mode = "append"
-
-            if write_mode in (None, "", "overwrite"):
-                create_iceberg_table(
-                    snowpark_table_name=snowpark_table_name,
-                    location=write_op.options.get("location", None),
-                    schema=input_df.schema,
-                    snowpark_session=session,
-                )
-                write_mode = "append"
-            input_df.write.saveAsTable(table_name=snowpark_table_name, mode=write_mode)
+            match write_mode:
+                case None | "error" | "errorifexists":
+                    if check_snowflake_table_existence(snowpark_table_name, session):
+                        raise AnalysisException(
+                            f"Table {snowpark_table_name} already exists"
+                        )
+                    create_iceberg_table(
+                        snowpark_table_name=snowpark_table_name,
+                        location=write_op.options.get("location", None),
+                        schema=input_df.schema,
+                        snowpark_session=session,
+                    )
+                    _validate_schema_and_get_writer(
+                        input_df, "append", snowpark_table_name
+                    ).saveAsTable(
+                        table_name=snowpark_table_name,
+                        mode="append",
+                        column_order=_column_order_for_write,
+                    )
+                case "append":
+                    _validate_schema_and_get_writer(
+                        input_df, "append", snowpark_table_name
+                    ).saveAsTable(
+                        table_name=snowpark_table_name,
+                        mode="append",
+                        column_order=_column_order_for_write,
+                    )
+                case "ignore":
+                    if not check_snowflake_table_existence(
+                        snowpark_table_name, session
+                    ):
+                        create_iceberg_table(
+                            snowpark_table_name=snowpark_table_name,
+                            location=write_op.options.get("location", None),
+                            schema=input_df.schema,
+                            snowpark_session=session,
+                        )
+                        _validate_schema_and_get_writer(
+                            input_df, "append", snowpark_table_name
+                        ).saveAsTable(
+                            table_name=snowpark_table_name,
+                            mode="append",
+                            column_order=_column_order_for_write,
+                        )
+                case "overwrite":
+                    if check_snowflake_table_existence(snowpark_table_name, session):
+                        session.sql(f"DELETE FROM {snowpark_table_name}").collect()
+                    else:
+                        create_iceberg_table(
+                            snowpark_table_name=snowpark_table_name,
+                            location=write_op.options.get("location", None),
+                            schema=input_df.schema,
+                            snowpark_session=session,
+                        )
+                    _validate_schema_and_get_writer(
+                        input_df, "append", snowpark_table_name
+                    ).saveAsTable(
+                        table_name=snowpark_table_name,
+                        mode="append",
+                        column_order=_column_order_for_write,
+                    )
+                case _:
+                    raise SnowparkConnectNotImplementedError(
+                        f"Write mode {write_mode} is not supported"
+                    )
         case _:
             snowpark_table_name = _spark_to_snowflake(write_op.table.table_name)
 
@@ -228,17 +286,23 @@ def map_write(request: proto_base.ExecutePlanRequest):
                 write_op.table.save_method
                 == commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_SAVE_AS_TABLE
             ):
-                input_df.write.saveAsTable(
+                _validate_schema_and_get_writer(
+                    input_df, write_mode, snowpark_table_name
+                ).saveAsTable(
                     table_name=snowpark_table_name,
                     mode=write_mode,
+                    column_order=_column_order_for_write,
                 )
             elif (
                 write_op.table.save_method
                 == commands_proto.WriteOperation.SaveTable.TableSaveMethod.TABLE_SAVE_METHOD_INSERT_INTO
             ):
-                input_df.write.saveAsTable(
+                _validate_schema_and_get_writer(
+                    input_df, write_mode, snowpark_table_name
+                ).saveAsTable(
                     table_name=snowpark_table_name,
                     mode=write_mode or "append",
+                    column_order=_column_order_for_write,
                 )
             else:
                 raise SnowparkConnectNotImplementedError(
@@ -265,10 +329,8 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
             )
 
     snowpark_table_name = _spark_to_snowflake(write_op.table_name)
-
-    input_df: snowpark.DataFrame = handle_column_names(
-        map_relation(write_op.input), "table"
-    )
+    result = map_relation(write_op.input)
+    input_df: snowpark.DataFrame = handle_column_names(result, "table")
     session: snowpark.Session = get_or_create_snowpark_session()
 
     if write_op.table_name is None or write_op.table_name == "":
@@ -281,14 +343,14 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
         commands_proto.WriteOperationV2.MODE_OVERWRITE,
         commands_proto.WriteOperationV2.MODE_APPEND,
     ):
-        if not check_snowflake_table_existance(snowpark_table_name, session):
+        if not check_snowflake_table_existence(snowpark_table_name, session):
             raise AnalysisException(
                 f"[TABLE_OR_VIEW_NOT_FOUND] The table or view `{write_op.table_name}` cannot be found. "
                 f"Verify the spelling and correctness of the schema and catalog.\n"
             )
 
     if write_op.provider.lower() == "iceberg":
-        if write_mode == "overwrite" and check_snowflake_table_existance(
+        if write_mode == "overwrite" and check_snowflake_table_existence(
             snowpark_table_name, session
         ):
             session.sql(f"DELETE FROM {snowpark_table_name}").collect()
@@ -304,16 +366,161 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
                 schema=input_df.schema,
                 snowpark_session=session,
             )
-
-        input_df.write.saveAsTable(
+        _validate_schema_and_get_writer(
+            input_df, write_mode, snowpark_table_name
+        ).saveAsTable(
             table_name=snowpark_table_name,
             mode="append",
+            column_order=_column_order_for_write,
         )
     else:
-        input_df.write.saveAsTable(
+        _validate_schema_and_get_writer(
+            input_df, write_mode, snowpark_table_name
+        ).saveAsTable(
             table_name=snowpark_table_name,
             mode=write_mode,
+            column_order=_column_order_for_write,
+        )
+
+
+def _validate_schema_and_get_writer(
+    input_df: snowpark.DataFrame, write_mode: str, snowpark_table_name: str
+) -> snowpark.DataFrameWriter:
+    if write_mode == "overwrite":
+        return input_df.write
+
+    table_schema = None
+    try:
+        table_schema = (
+            get_or_create_snowpark_session().table(snowpark_table_name).schema
         )
+    except SnowparkSQLException as e:
+        msg = e.message
+        if "SQL compilation error" in msg and "does not exist" in msg:
+            pass
+        else:
+            raise e
+
+    if table_schema is None:
+        # If table does not exist, we can skip the schema validation
+        return input_df.write
+
+    _validate_schema_for_append(table_schema, input_df.schema, snowpark_table_name)
+
+    # if table exists and case sensitivity is not enabled, we need to rename the columns to match existing table schema
+    if not global_config.spark_sql_caseSensitive:
+
+        for field in input_df.schema.fields:
+            # Find the matching field in the table schema (case-insensitive)
+            col_name = field.name
+            renamed = col_name
+            matching_field = next(
+                (f for f in table_schema.fields if f.name.lower() == col_name.lower()),
+                None,
+            )
+            if matching_field is not None and matching_field != col_name:
+                renamed = matching_field.name
+                input_df = input_df.withColumnRenamed(col_name, renamed)
+                # Cast column if type does not match
+
+            if field.datatype != matching_field.datatype:
+                if isinstance(matching_field.datatype, StructType):
+                    input_df = input_df.withColumn(
+                        renamed,
+                        col(renamed).cast(matching_field.datatype, rename_fields=True),
+                    )
+                else:
+                    input_df = input_df.withColumn(
+                        renamed, col(renamed).cast(matching_field.datatype)
+                    )
+    return input_df.write
+
+
+def _validate_schema_for_append(
+    table_schema: DataType, data_schema: DataType, snowpark_table_name: str
+):
+    match (table_schema, data_schema):
+        case (_, _) if table_schema == data_schema:
+            return
+
+        case (StructType() as table_struct, StructType() as data_struct):
+
+            def _comparable_col_name(col: str) -> str:
+                return col if global_config.spark_sql_caseSensitive else col.lower()
+
+            def invalid_struct_schema():
+                raise AnalysisException(
+                    f"Cannot resolve columns for the existing table {snowpark_table_name} ({table_schema.simple_string()}) with the data schema ({data_schema.simple_string()})."
+                )
+
+            if len(table_struct.fields) != len(data_struct.fields):
+                raise AnalysisException(
+                    f"The column number of the existing table {snowpark_table_name} ({table_schema.simple_string()}) doesn't match the data schema ({data_schema.simple_string()}).)"
+                )
+
+            table_field_names = {
+                _comparable_col_name(field.name) for field in table_struct.fields
+            }
+            data_field_names = {
+                _comparable_col_name(field.name) for field in data_struct.fields
+            }
+
+            if table_field_names != data_field_names:
+                invalid_struct_schema()
+
+            for data_field in data_struct.fields:
+                matching_table_field = next(
+                    (
+                        f
+                        for f in table_struct.fields
+                        if _comparable_col_name(f.name)
+                        == _comparable_col_name(data_field.name)
+                    ),
+                    None,
+                )
+
+                if matching_table_field is None:
+                    invalid_struct_schema()
+                else:
+                    _validate_schema_for_append(
+                        matching_table_field.datatype,
+                        data_field.datatype,
+                        snowpark_table_name,
+                    )
+
+            return
+
+        case (StringType(), _) if not isinstance(
+            data_schema, (StructType, ArrayType, MapType, TimestampType, DateType)
+        ):
+            return
+
+        case (_, _) if isinstance(table_schema, _NumericType) and isinstance(
+            data_schema, _NumericType
+        ):
+            return
+
+        case (ArrayType() as table_array, ArrayType() as data_array):
+            _validate_schema_for_append(
+                table_array.element_type, data_array.element_type, snowpark_table_name
+            )
+
+        case (MapType() as table_map, MapType() as data_map):
+            _validate_schema_for_append(
+                table_map.key_type, data_map.key_type, snowpark_table_name
+            )
+            _validate_schema_for_append(
+                table_map.value_type, data_map.value_type, snowpark_table_name
+            )
+
+        case (TimestampType(), _) if isinstance(data_schema, (DateType, TimestampType)):
+            return
+        case (DateType(), _) if isinstance(data_schema, (DateType, TimestampType)):
+            return
+        case (_, _):
+            raise AnalysisException(
+                f"[INCOMPATIBLE_DATA_FOR_TABLE.CANNOT_SAFELY_CAST] Cannot write incompatible data for the table {snowpark_table_name}: Cannot safely cast {data_schema.simple_string()} to {table_schema.simple_string()}"
+            )
 
 
 def create_iceberg_table(
@@ -323,7 +530,7 @@ def create_iceberg_table(
     snowpark_session: snowpark.Session,
 ):
     table_schema = [
-        f"{_spark_to_snowflake_single_id(field.name)} {snowpark_to_iceberg_type(field.datatype)}"
+        f"{spark_to_sf_single_id(unquote_if_quoted(field.name), is_column = True)} {snowpark_to_iceberg_type(field.datatype)}"
         for field in schema.fields
     ]
 
@@ -374,26 +581,22 @@ def rewrite_df(input_df: snowpark.DataFrame, source: str) -> snowpark.DataFrame:
     return rewritten_df.select(object_construct(*construct_key_values))
 
 
-def handle_column_names(df: snowpark.DataFrame, source: str) -> snowpark.DataFrame:
+def handle_column_names(
+    container: DataFrameContainer, source: str
+) -> snowpark.DataFrame:
     """
-    Handle column names.
-
-    Quote column name in these scenarios:
-        0. Not write to table
-        1. Customer enabled case sensitivity in config
+    Handle column names before write so they match spark schema.
     """
-    if not hasattr(df, "_column_map") or source == "jdbc":
+    df = container.dataframe
+    if source == "jdbc":
         # don't change column names for jdbc sources as we directly use spark column names for writing to the destination tables.
         return df
-    column_map = df._column_map
-    case_sensitive = global_config.spark_sql_caseSensitive
-    for column in df.columns:
-        spark_column_name = unquote_if_quoted(
-            column_map.get_spark_column_name_from_snowpark_column_name(column)
+    column_map = container.column_map
+
+    for column in column_map.columns:
+        df = df.withColumnRenamed(
+            column.snowpark_name, quote_name_without_upper_casing(column.spark_name)
         )
-        if source in ("csv", "parquet", "json") or case_sensitive:
-            spark_column_name = f'"{spark_column_name}"'
-        df = df.withColumnRenamed(column, spark_column_name)
     return df
 
 
@@ -425,7 +628,7 @@ def _truncate_directory(directory_path: Path) -> None:
             shutil.rmtree(file)
 
 
-def check_snowflake_table_existance(
+def check_snowflake_table_existence(
     snowpark_table_name: str,
     snowpark_session: snowpark.Session,
 ):

snowflake/snowpark_connect/relation/write/map_write_jdbc.py

@@ -3,6 +3,7 @@
 #
 
 from snowflake import snowpark
+from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.read.map_read_jdbc import (
     close_connection,
     create_connection,
@@ -14,7 +15,7 @@ from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 
 
 def map_write_jdbc(
-    input_df: snowpark.DataFrame,
+    container: DataFrameContainer,
     session: snowpark.Session,
     options: dict[str, str],
     write_mode: str,
@@ -38,7 +39,7 @@ def map_write_jdbc(
 
     try:
         JdbcDataFrameWriter(session, jdbc_options).jdbc_write_dbapi(
-            input_df,
+            container,
             create_connection,
             close_connection,
             table=dbtable,

snowflake/snowpark_connect/server.py

@@ -112,10 +112,38 @@ _SPARK_CONNECT_GRPC_MAX_MESSAGE_SIZE = 128 * 1024 * 1024
 _SPARK_CONNECT_GRPC_MAX_METADATA_SIZE = 64 * 1024  # 64kb
 
 
+def _sanitize_file_paths(text: str) -> str:
+    """
+    Sanitize file paths in error messages by replacing them with placeholders.
+    Only matches actual file paths, not module names or class names.
+    """
+    import re
+
+    # Pattern to match file paths in traceback "File" lines only
+    # This targets the specific format: File "/path/to/file.py", line XX
+    file_line_pattern = r'(File\s+["\'])([^"\']+)(["\'],\s+line\s+\d+)'
+
+    def replace_file_path(match):
+        return f"{match.group(1)}<redacted_file_path>{match.group(3)}"
+
+    return re.sub(file_line_pattern, replace_file_path, text)
+
+
 def _handle_exception(context, e: Exception):
     import traceback
 
-    traceback.print_exc()
+    # traceback.print_exc()
+    # SNOWFLAKE_SHOW_ERROR_TRACE controls sanitized traceback printing (default: false)
+    show_traceback = os.getenv("SNOWFLAKE_SHOW_ERROR_TRACE", "false").lower() == "true"
+
+    if show_traceback:
+        # Show detailed traceback (includes error info naturally)
+        error_traceback = traceback.format_exc()
+        sanitized_traceback = _sanitize_file_paths(error_traceback)
+        logger.error(sanitized_traceback)
+    else:
+        # Show only basic error information, no traceback
+        logger.error("Error: %s - %s", type(e).__name__, str(e))
 
     telemetry.report_request_failure(e)
 
@@ -195,12 +223,13 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
             telemetry.initialize_request_summary(request)
             match request.WhichOneof("analyze"):
                 case "schema":
-                    snowpark_df = map_relation(request.schema.plan.root)
+                    result = map_relation(request.schema.plan.root)
+                    snowpark_df = result.dataframe
                     snowpark_schema: snowpark.types.StructType = snowpark_df.schema
                     schema = proto_base.AnalyzePlanResponse.Schema(
                         schema=types_proto.DataType(
                             **snowpark_to_proto_type(
-                                snowpark_schema, snowpark_df._column_map, snowpark_df
+                                snowpark_schema, result.column_map, snowpark_df
                             )
                         )
                     )
@@ -262,7 +291,8 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
                     # Snowflake only exposes simplified execution plans, similar to Spark's optimized logical plans.
                     # Snowpark provides the execution plan IFF the dataframe maps to a single query.
                     # TODO: Do we need to return a Spark-like plan?
-                    snowpark_df = map_relation(request.explain.plan.root)
+                    result = map_relation(request.explain.plan.root)
+                    snowpark_df = result.dataframe
                     return proto_base.AnalyzePlanResponse(
                         session_id=request.session_id,
                         explain=proto_base.AnalyzePlanResponse.Explain(
@@ -951,6 +981,7 @@ def start_session(
     stop_event: threading.Event = None,
     snowpark_session: Optional[snowpark.Session] = None,
     connection_parameters: Optional[Dict[str, str]] = None,
+    max_grpc_message_size: int = _SPARK_CONNECT_GRPC_MAX_MESSAGE_SIZE,
 ) -> threading.Thread | None:
     """
     Starts Spark Connect server connected to Snowflake. No-op if the Server is already running.
@@ -973,6 +1004,14 @@ def start_session(
                                 provided, the `snowpark_session` parameter must be None.
     """
     try:
+        # Changing the value of our global variable based on the grpc message size provided by the user.
+        global _SPARK_CONNECT_GRPC_MAX_MESSAGE_SIZE
+        _SPARK_CONNECT_GRPC_MAX_MESSAGE_SIZE = max_grpc_message_size
+
+        from pyspark.sql.connect.client import ChannelBuilder
+
+        ChannelBuilder.MAX_MESSAGE_LENGTH = max_grpc_message_size
+
         if os.environ.get("SPARK_ENV_LOADED"):
             raise RuntimeError(
                 "Snowpark Connect cannot be run inside of a Spark environment"

snowflake/snowpark_connect/type_mapping.py

@@ -52,10 +52,6 @@ SNOWPARK_TYPE_NAME_TO_PYSPARK_TYPE_NAME = {
     snowpark.types.TimestampType.__name__: pyspark.sql.types.TimestampType.typeName(),
 }
 
-_STRUCT_MATCH_PATTERN = re.compile(r"struct<(.+)>", re.IGNORECASE)
-_STRUCT_REPLACE_PATTERN = re.compile(r"struct<[^>]*>", re.IGNORECASE)
-_MAP_REPLACE_PATTERN = re.compile(r"map<[^>]*>", re.IGNORECASE)
-
 
 @cache
 def _get_struct_type_class():
@@ -206,7 +202,7 @@ def snowpark_to_proto_type(
                     if (
                         metadata is None
                         and df
-                        and field.name in df._column_map.get_snowpark_columns()
+                        and field.name in column_name_map.get_snowpark_columns()
                     ):
                         try:
                             # check for collision using expr_id
@@ -328,6 +324,8 @@ def cast_to_match_snowpark_type(
             return str(content)
         case snowpark.types.VariantType:
             return str(content)
+        case snowpark.types.TimestampType:
+            return str(content)
         case _:
             raise SnowparkConnectNotImplementedError(
                 f"Unsupported snowpark data type in casting: {data_type}"
@@ -499,7 +497,7 @@ def map_snowpark_types_to_pyarrow_types(
                 return pa.string()
             if pa.types.is_struct(pa_type):
                 return pa.struct(
-                    fields=[
+                    [
                         pa.field(
                             field.name if not rename_struct_columns else str(i),
                             map_snowpark_types_to_pyarrow_types(
@@ -783,6 +781,8 @@ def map_simple_types(simple_type: str) -> snowpark.types.DataType:
             return snowpark.types.TimestampType()
         case "timestamp_ntz":
             return snowpark.types.TimestampType(snowpark.types.TimestampTimeZone.NTZ)
+        case "timestamp_ltz":
+            return snowpark.types.TimestampType(snowpark.types.TimestampTimeZone.LTZ)
         case "day_time_interval":
             # this is not a column type in snowflake so there won't be a dataframe column
             # with this, for now this type won't make any sense
@@ -869,23 +869,6 @@ def map_json_schema_to_snowpark(
             return map_simple_types(schema["type"])
 
 
-def _replace_complex_patterns(type_string):
-    # Check if entire string matches struct pattern "struct<col1 int, col2 int, col3 int, col4 int>"
-    type_string = re.sub(
-        r"decimal\s*\(\s*\d+\s*,\s*\d+\s*\)",
-        "decimal",
-        type_string,
-        flags=re.IGNORECASE,
-    )
-    struct_match = _STRUCT_MATCH_PATTERN.match(type_string)
-    if struct_match:
-        return struct_match.group(1).replace(":", " ")
-    # Replace 'struct<[^>]*>' with 'struct' and map<*> with map as we are only interested in column names.
-    type_string = _STRUCT_REPLACE_PATTERN.sub("struct", type_string)
-    type_string = _MAP_REPLACE_PATTERN.sub("map", type_string)
-    return type_string.replace(":", " ")
-
-
 def map_type_string_to_snowpark_type(type_string: str) -> snowpark.types.DataType:
     """
     Converts a pyspark type string like x: int or struct<x: int, y: string> etc. to a snowpark type.