snowpark-connect 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

snowflake/snowpark_connect/relation/read/map_read.py

@@ -65,7 +65,7 @@ def map_read(
                 read_format = "parquet"
 
             if read_format.lower() == "iceberg":
-                telemetry.report_io_read("iceberg", None)
+                telemetry.report_io_read("iceberg")
                 return map_read_table(rel)
 
             if rel.read.data_source.schema == "":
@@ -90,7 +90,7 @@ def map_read(
                         )
                 schema = map_json_schema_to_snowpark(parsed_schema)
             options = dict(rel.read.data_source.options)
-            telemetry.report_io_read(read_format, options)
+            telemetry.report_io_read(read_format)
             session: snowpark.Session = get_or_create_snowpark_session()
             if len(rel.read.data_source.paths) > 0:
                 # Normalize paths to ensure consistent behavior
@@ -175,7 +175,7 @@ def map_read_table_or_file(rel):
             rel.read.named_table.unparsed_identifier
         )
         options = {}
-        telemetry.report_io_read(read_format, options)
+        telemetry.report_io_read(read_format)
         session: snowpark.Session = get_or_create_snowpark_session()
 
         clean_source_paths = [

snowflake/snowpark_connect/relation/read/map_read_jdbc.py

@@ -94,7 +94,7 @@ def map_read_jdbc(
             num_partitions=num_partitions,
             predicates=predicates,
         )
-        true_names = list(map(lambda x: unquote_if_quoted(x).lower(), df.columns))
+        true_names = list(map(lambda x: unquote_if_quoted(x), df.columns))
         renamed_df, snowpark_cols = rename_columns_as_snowflake_standard(
             df, rel.common.plan_id
         )

snowflake/snowpark_connect/relation/read/map_read_json.py

@@ -34,6 +34,7 @@ from snowflake.snowpark_connect.type_mapping import (
     cast_to_match_snowpark_type,
     map_simple_types,
 )
+from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
@@ -66,6 +67,7 @@ def map_read_json(
 
         rows_to_infer_schema = snowpark_options.pop("rowstoinferschema", 1000)
         dropFieldIfAllNull = snowpark_options.pop("dropfieldifallnull", False)
+        batch_size = snowpark_options.pop("batchsize", 1000)
 
         reader = session.read.options(snowpark_options)
 
@@ -99,7 +101,7 @@ def map_read_json(
                 ]
 
         df = construct_dataframe_by_schema(
-            schema, df.to_local_iterator(), session, snowpark_options
+            schema, df.to_local_iterator(), session, snowpark_options, batch_size
         )
 
         spark_column_names = get_spark_column_names_from_snowpark_columns(df.columns)
@@ -277,9 +279,11 @@ def construct_dataframe_by_schema(
     result = None
 
     current_data = []
+    progress = 0
     for row in rows:
         current_data.append(construct_row_by_schema(row, schema, snowpark_options))
         if len(current_data) >= batch_size:
+            progress += len(current_data)
             result = union_data_into_df(
                 result,
                 current_data,
@@ -287,9 +291,11 @@ def construct_dataframe_by_schema(
                 session,
             )
 
+            logger.info(f"JSON reader: finished processing {progress} rows")
             current_data = []
 
     if len(current_data) > 0:
+        progress += len(current_data)
         result = union_data_into_df(
             result,
             current_data,
@@ -297,6 +303,7 @@ def construct_dataframe_by_schema(
             session,
         )
 
+        logger.info(f"JSON reader: finished processing {progress} rows")
         current_data = []
 
     if result is None:

snowflake/snowpark_connect/relation/read/map_read_table.py

@@ -11,7 +11,6 @@ from snowflake.snowpark._internal.analyzer.analyzer_utils import (
     unquote_if_quoted,
 )
 from snowflake.snowpark.exceptions import SnowparkSQLException
-from snowflake.snowpark_connect.column_name_handler import ALREADY_QUOTED
 from snowflake.snowpark_connect.config import auto_uppercase_non_column_identifiers
 from snowflake.snowpark_connect.dataframe_container import DataFrameContainer
 from snowflake.snowpark_connect.relation.read.utils import (
@@ -29,15 +28,8 @@ from snowflake.snowpark_connect.utils.telemetry import (
 def post_process_df(
     df: snowpark.DataFrame, plan_id: int, source_table_name: str = None
 ) -> DataFrameContainer:
-    def _lower_or_unquote(string):
-        return (
-            string[1:-1].replace('""', '"')
-            if ALREADY_QUOTED.match(string)
-            else string.lower()
-        )
-
     try:
-        true_names = list(map(lambda x: _lower_or_unquote(x), df.columns))
+        true_names = list(map(lambda x: unquote_if_quoted(x), df.columns))
         renamed_df, snowpark_column_names = rename_columns_as_snowflake_standard(
             df, plan_id
         )

snowflake/snowpark_connect/relation/read/reader_config.py

@@ -317,6 +317,7 @@ class JsonReaderConfig(ReaderWriterConfig):
                     # TODO: modifiedAfter: Union[bool, str, None] = None,
                     # TODO: allowNonNumericNumbers: Union[bool, str, None] = None,
                     "rowsToInferSchema": 1000,
+                    "batchSize": 1000,
                 },
                 supported_options={
                     "schema",
@@ -347,12 +348,13 @@ class JsonReaderConfig(ReaderWriterConfig):
                     # "ignoreNullFields",
                     "rowsToInferSchema",
                     # "inferTimestamp",
+                    "batchSize",
                 },
                 boolean_config_list=[
                     "multiLine",
                     "dropFieldIfAllNull",
                 ],
-                int_config_list=["rowsToInferSchema"],
+                int_config_list=["rowsToInferSchema", "batchSize"],
                 float_config_list=["samplingRatio"],
             ),
             options,

snowflake/snowpark_connect/relation/read/utils.py

@@ -73,13 +73,12 @@ def rename_columns_as_snowflake_standard(
         return df, []
 
     new_columns = make_column_names_snowpark_compatible(df.columns, plan_id)
-    result = df.toDF(*new_columns)
-    if result._select_statement is not None:
-        # do not allow snowpark to flatten the to_df result
-        # TODO: remove after SNOW-2203706 is fixed
-        result._select_statement.flatten_disabled = True
-
-    return (result, new_columns)
+    return (
+        df.select(
+            *(df.col(orig).alias(alias) for orig, alias in zip(df.columns, new_columns))
+        ),
+        new_columns,
+    )
 
 
 class Connection(Protocol):

snowflake/snowpark_connect/relation/utils.py

@@ -6,28 +6,12 @@ import random
 import re
 import string
 import time
-from collections.abc import Callable
-from typing import AbstractSet, List, Optional, Sequence
+from typing import Sequence
 
 import pyspark.sql.connect.proto.relations_pb2 as relation_proto
 
 import snowflake.snowpark.functions as snowpark_fn
 from snowflake import snowpark
-from snowflake.snowpark._internal.analyzer.expression import (
-    COLUMN_DEPENDENCY_ALL,
-    COLUMN_DEPENDENCY_DOLLAR,
-    Expression,
-    FunctionExpression,
-    derive_dependent_columns,
-)
-from snowflake.snowpark._internal.analyzer.select_statement import (
-    SEQUENCE_DEPENDENT_DATA_GENERATION,
-    ColumnChangeState,
-    ColumnStateDict,
-    SelectStatement,
-)
-from snowflake.snowpark._internal.analyzer.unary_expression import Alias
-from snowflake.snowpark._internal.analyzer.window_expression import WindowExpression
 from snowflake.snowpark.types import (
     BinaryType,
     BooleanType,
@@ -239,156 +223,3 @@ def snowpark_functions_col(name: str, column_map: ColumnNameMap) -> snowpark.Col
     """
     is_qualified_name = name not in column_map.get_snowpark_columns()
     return snowpark_fn.col(name, _is_qualified_name=is_qualified_name)
-
-
-def can_sort_be_flattened(
-    select_statement: Optional[SelectStatement], *sort_expressions: Optional[Expression]
-) -> bool:
-    """
-    Checks if the given SelectStatement can be "flattened" when sorting with regard to the given sort expressions.
-    Flattening means that the given SelectStatement can be enhanced and reused instead of being treated
-    as a subquery in the FROM clause after a "sort" or "filter" operation. Flattening allows accessing dropped columns
-    for sort and filter expressions.
-    """
-    if not select_statement or select_statement.flatten_disabled:
-        return False
-
-    # In some cases, flattening sort can lead to leaving the "order by" clause in a subquery,
-    # which can cause incorrect ordering. We want to avoid flattening sort when all its dependent columns
-    # are available in the current projection.
-    dependent_columns_in_sort = derive_dependent_columns(*sort_expressions)
-    columns_in_projection = _get_columns_in_projection(select_statement.projection)
-    if len(dependent_columns_in_sort - columns_in_projection) == 0:
-        return False
-
-    return _can_clause_dependent_columns_flatten(
-        dependent_columns_in_sort, select_statement.column_states
-    ) and not _has_data_generator_exp(select_statement.projection)
-
-
-def can_filter_be_flattened(
-    select_statement: Optional[SelectStatement], condition: Expression
-) -> bool:
-    """
-    Checks if the given SelectStatement can be "flattened" when filtering with regard to the given condition.
-    Flattening means that the given SelectStatement can be enhanced and reused instead of being treated
-    as a subquery in the FROM clause after a "sort" or "filter" operation. Flattening allows accessing dropped columns
-    for sort and filter expressions.
-    """
-    if not select_statement or select_statement.flatten_disabled:
-        return False
-
-    return all(
-        [
-            _can_clause_dependent_columns_flatten(
-                derive_dependent_columns(condition), select_statement.column_states
-            ),
-            not _has_data_generator_or_window_exp(select_statement.projection),
-            select_statement.order_by is None,
-            select_statement.limit_ is None,
-        ]
-    )
-
-
-def _get_columns_in_projection(
-    projection: Optional[List[Expression]],
-) -> AbstractSet[str]:
-    if projection is None:
-        return set()
-
-    columns = set()
-    for expression in projection:
-        if hasattr(expression, "name") and expression.name:
-            columns.add(expression.name)
-        elif hasattr(expression, "children"):
-            columns.update(_get_columns_in_projection(expression.children))
-
-    return columns
-
-
-def _is_self_alias(expression):
-    """
-    Check if the expression is a self-alias, meaning it has an alias that is the same as its name.
-    A self-alias can be flattened, even if Snowpark treats it as a CHANGED_EXP.
-    """
-    if not isinstance(expression, Alias):
-        return False
-
-    first_child_with_name = expression.child
-    while (
-        first_child_with_name
-        and hasattr(first_child_with_name, "child")
-        and not hasattr(first_child_with_name, "name")
-    ):
-        first_child_with_name = first_child_with_name.child
-
-    return (
-        first_child_with_name
-        and (first_child_with_name, "name")
-        and first_child_with_name.name == expression.name
-    )
-
-
-def _can_clause_dependent_columns_flatten(
-    dependent_columns: Optional[AbstractSet[str]],
-    subquery_column_states: ColumnStateDict,
-) -> bool:
-    if dependent_columns == COLUMN_DEPENDENCY_DOLLAR:
-        return False
-    elif (
-        subquery_column_states.has_changed_columns
-        or subquery_column_states.has_new_columns
-    ):
-        if dependent_columns == COLUMN_DEPENDENCY_ALL:
-            return False
-
-        assert dependent_columns is not None
-        for dc in dependent_columns:
-            dc_state = subquery_column_states.get(dc)
-            if dc_state:
-                if (
-                    dc_state.change_state == ColumnChangeState.CHANGED_EXP
-                    and not _is_self_alias(dc_state.expression)
-                ):
-                    return False
-    return True
-
-
-def _has_data_generator_exp(expressions: List[Expression]) -> bool:
-    return _has_expression(expressions, [_is_generator_expression])
-
-
-def _has_data_generator_or_window_exp(expressions: List[Expression]) -> bool:
-    return _has_expression(
-        expressions, [_is_generator_expression, _is_window_expression]
-    )
-
-
-def _has_expression(
-    expressions: Optional[List[Expression]], checks: List[Callable[[Expression], bool]]
-) -> bool:
-    if expressions is None:
-        return False
-
-    for exp in expressions:
-        if not exp:
-            continue
-
-        if any([check(exp) for check in checks]):
-            return True
-
-        if _has_expression(exp.children, checks):
-            return True
-
-    return False
-
-
-def _is_window_expression(exp: Expression) -> bool:
-    return isinstance(exp, WindowExpression)
-
-
-def _is_generator_expression(exp: Expression) -> bool:
-    # https://docs.snowflake.com/en/sql-reference/functions-data-generation
-    return isinstance(exp, FunctionExpression) and (
-        exp.is_data_generator or exp.name.lower() in SEQUENCE_DEPENDENT_DATA_GENERATION
-    )

snowflake/snowpark_connect/relation/write/map_write.py

@@ -107,10 +107,7 @@ def _spark_to_snowflake(multipart_id: str) -> str:
 
 def map_write(request: proto_base.ExecutePlanRequest):
     write_op = request.plan.command.write_operation
-    if write_op.options is not None:
-        telemetry.report_io_write(write_op.source, dict(write_op.options))
-    else:
-        telemetry.report_io_write(write_op.source)
+    telemetry.report_io_write(write_op.source)
 
     write_mode = None
     match write_op.mode:
@@ -234,10 +231,11 @@ def map_write(request: proto_base.ExecutePlanRequest):
                         column_order=_column_order_for_write,
                     )
                 case "append":
-                    if check_table_type(snowpark_table_name, session) != "ICEBERG":
-                        raise AnalysisException(
-                            f"Table {snowpark_table_name} is not an iceberg table"
-                        )
+                    # TODO: SNOW-2299414 Fix the implementation of table type check
+                    # if check_table_type(snowpark_table_name, session) != "ICEBERG":
+                    #     raise AnalysisException(
+                    #         f"Table {snowpark_table_name} is not an iceberg table"
+                    #     )
                     _validate_schema_and_get_writer(
                         input_df, "append", snowpark_table_name
                     ).saveAsTable(
@@ -264,10 +262,12 @@ def map_write(request: proto_base.ExecutePlanRequest):
                         )
                 case "overwrite":
                     if check_snowflake_table_existence(snowpark_table_name, session):
-                        if check_table_type(snowpark_table_name, session) != "ICEBERG":
-                            raise AnalysisException(
-                                f"Table {snowpark_table_name} is not an iceberg table"
-                            )
+                        # TODO: SNOW-2299414 Fix the implementation of table type check
+                        # if check_table_type(snowpark_table_name, session) != "ICEBERG":
+                        #     raise AnalysisException(
+                        #         f"Table {snowpark_table_name} is not an iceberg table"
+                        #     )
+                        pass
                     else:
                         create_iceberg_table(
                             snowpark_table_name=snowpark_table_name,
@@ -298,13 +298,14 @@ def map_write(request: proto_base.ExecutePlanRequest):
                         if check_snowflake_table_existence(
                             snowpark_table_name, session
                         ):
-                            if (
-                                check_table_type(snowpark_table_name, session)
-                                != "TABLE"
-                            ):
-                                raise AnalysisException(
-                                    f"Table {snowpark_table_name} is not a FDN table"
-                                )
+                            # TODO: SNOW-2299414 Fix the implementation of table type check
+                            # if (
+                            #     check_table_type(snowpark_table_name, session)
+                            #     != "TABLE"
+                            # ):
+                            #     raise AnalysisException(
+                            #         f"Table {snowpark_table_name} is not a FDN table"
+                            #     )
                             write_mode = "truncate"
                         _validate_schema_and_get_writer(
                             input_df, write_mode, snowpark_table_name
@@ -314,10 +315,11 @@ def map_write(request: proto_base.ExecutePlanRequest):
                             column_order=_column_order_for_write,
                         )
                     case "append":
-                        if check_table_type(snowpark_table_name, session) != "TABLE":
-                            raise AnalysisException(
-                                f"Table {snowpark_table_name} is not a FDN table"
-                            )
+                        # TODO: SNOW-2299414 Fix the implementation of table type check
+                        # if check_table_type(snowpark_table_name, session) != "TABLE":
+                        #     raise AnalysisException(
+                        #         f"Table {snowpark_table_name} is not a FDN table"
+                        #     )
                         _validate_schema_and_get_writer(
                             input_df, write_mode, snowpark_table_name
                         ).saveAsTable(
@@ -388,10 +390,11 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
                     raise AnalysisException(
                         f"[TABLE_OR_VIEW_NOT_FOUND] The table or view `{write_op.table_name}` cannot be found."
                     )
-                if check_table_type(snowpark_table_name, session) != "ICEBERG":
-                    raise AnalysisException(
-                        f"Table {snowpark_table_name} is not an iceberg table"
-                    )
+                # TODO: SNOW-2299414 Fix the implementation of table type check
+                # if check_table_type(snowpark_table_name, session) != "ICEBERG":
+                #     raise AnalysisException(
+                #         f"Table {snowpark_table_name} is not an iceberg table"
+                #     )
                 _validate_schema_and_get_writer(
                     input_df, "append", snowpark_table_name
                 ).saveAsTable(
@@ -402,10 +405,12 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
             case commands_proto.WriteOperationV2.MODE_OVERWRITE | commands_proto.WriteOperationV2.MODE_OVERWRITE_PARTITIONS:
                 # TODO: handle the filter condition for MODE_OVERWRITE
                 if check_snowflake_table_existence(snowpark_table_name, session):
-                    if check_table_type(snowpark_table_name, session) != "ICEBERG":
-                        raise AnalysisException(
-                            f"Table {snowpark_table_name} is not an iceberg table"
-                        )
+                    # TODO: SNOW-2299414 Fix the implementation of table type check
+                    # if check_table_type(snowpark_table_name, session) != "ICEBERG":
+                    #     raise AnalysisException(
+                    #         f"Table {snowpark_table_name} is not an iceberg table"
+                    #     )
+                    pass
                 else:
                     raise AnalysisException(
                         f"[TABLE_OR_VIEW_NOT_FOUND] Table {snowpark_table_name} does not exist"
@@ -471,10 +476,11 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
                     raise AnalysisException(
                         f"[TABLE_OR_VIEW_NOT_FOUND] The table or view `{write_op.table_name}` cannot be found."
                     )
-                if check_table_type(snowpark_table_name, session) != "TABLE":
-                    raise AnalysisException(
-                        f"Table {snowpark_table_name} is not a FDN table"
-                    )
+                # TODO: SNOW-2299414 Fix the implementation of table type check
+                # if check_table_type(snowpark_table_name, session) != "TABLE":
+                #     raise AnalysisException(
+                #         f"Table {snowpark_table_name} is not a FDN table"
+                #     )
                 _validate_schema_and_get_writer(
                     input_df, "append", snowpark_table_name
                 ).saveAsTable(
@@ -485,10 +491,12 @@ def map_write_v2(request: proto_base.ExecutePlanRequest):
             case commands_proto.WriteOperationV2.MODE_OVERWRITE | commands_proto.WriteOperationV2.MODE_OVERWRITE_PARTITIONS:
                 # TODO: handle the filter condition for MODE_OVERWRITE
                 if check_snowflake_table_existence(snowpark_table_name, session):
-                    if check_table_type(snowpark_table_name, session) != "TABLE":
-                        raise AnalysisException(
-                            f"Table {snowpark_table_name} is not a FDN table"
-                        )
+                    # TODO: SNOW-2299414 Fix the implementation of table type check
+                    # if check_table_type(snowpark_table_name, session) != "TABLE":
+                    #     raise AnalysisException(
+                    #         f"Table {snowpark_table_name} is not a FDN table"
+                    #     )
+                    pass
                 else:
                     raise AnalysisException(
                         f"[TABLE_OR_VIEW_NOT_FOUND] Table {snowpark_table_name} does not exist"
@@ -798,17 +806,18 @@ def check_snowflake_table_existence(
         return False
 
 
-def check_table_type(
-    snowpark_table_name: str,
-    snowpark_session: snowpark.Session,
-) -> str:
-    # currently we only support iceberg table and FDN table
-    metadata = snowpark_session.sql(
-        f"SHOW TABLES LIKE '{unquote_if_quoted(snowpark_table_name)}';"
-    ).collect()
-    if metadata is None or len(metadata) == 0:
-        raise AnalysisException(f"Table {snowpark_table_name} does not exist")
-    metadata = metadata[0]
-    if metadata.as_dict().get("is_iceberg") == "Y":
-        return "ICEBERG"
-    return "TABLE"
+# TODO: SNOW-2299414 Fix the implementation of table type check
+# def check_table_type(
+#     snowpark_table_name: str,
+#     snowpark_session: snowpark.Session,
+# ) -> str:
+#     # currently we only support iceberg table and FDN table
+#     metadata = snowpark_session.sql(
+#         f"SHOW TABLES LIKE '{unquote_if_quoted(snowpark_table_name)}';"
+#     ).collect()
+#     if metadata is None or len(metadata) == 0:
+#         raise AnalysisException(f"Table {snowpark_table_name} does not exist")
+#     metadata = metadata[0]
+#     if metadata.as_dict().get("is_iceberg") == "Y":
+#         return "ICEBERG"
+#     return "TABLE"

snowflake/snowpark_connect/resources_initializer.py

@@ -1,7 +1,7 @@
 #
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
-
+import pathlib
 import threading
 import time
 
@@ -9,6 +9,8 @@ from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_sess
 from snowflake.snowpark_connect.utils.snowpark_connect_logging import logger
 
 _resources_initialized = threading.Event()
+SPARK_VERSION = "3.5.6"
+RESOURCE_PATH = "/snowflake/snowpark_connect/resources"
 
 
 def initialize_resources() -> None:
@@ -41,6 +43,31 @@ def initialize_resources() -> None:
 
         session.sql("select 1 as sf_connection_warm_up").collect()
 
+    def upload_scala_udf_jars() -> None:
+        """Upload Spark jar files required for creating Scala UDFs."""
+        stage = session.get_session_stage()
+        resource_path = stage + RESOURCE_PATH
+        import snowflake
+
+        pyspark_jars = (
+            pathlib.Path(snowflake.snowpark_connect.__file__).parent / "includes/jars"
+        )
+        jar_files = [
+            f"spark-sql_2.12-{SPARK_VERSION}.jar",
+            f"spark-connect-client-jvm_2.12-{SPARK_VERSION}.jar",
+            f"spark-common-utils_2.12-{SPARK_VERSION}.jar",
+            "json4s-ast_2.12-3.7.0-M11.jar",
+        ]
+
+        for jar in jar_files:
+            session.file.put(
+                str(pyspark_jars) + "/" + jar,
+                resource_path,
+                auto_compress=False,
+                overwrite=False,
+                source_compression="NONE",
+            )
+
     start_time = time.time()
 
     resources = [
@@ -49,6 +76,7 @@ def initialize_resources() -> None:
         ("Initialize Session Stage", initialize_session_stage),  # Takes about 0.3s
         ("Initialize Session Catalog", initialize_catalog),  # Takes about 1.2s
         ("Snowflake Connection Warm Up", warm_up_sf_connection),  # Takes about 1s
+        ("Upload Scala UDF Jars", upload_scala_udf_jars),
     ]
 
     for name, resource_func in resources:

snowflake/snowpark_connect/server.py

@@ -68,10 +68,14 @@ from snowflake.snowpark_connect.relation.map_relation import map_relation
 from snowflake.snowpark_connect.relation.utils import get_semantic_string
 from snowflake.snowpark_connect.resources_initializer import initialize_resources_async
 from snowflake.snowpark_connect.type_mapping import (
-    parse_ddl_string,
+    map_type_string_to_proto,
     snowpark_to_proto_type,
 )
-from snowflake.snowpark_connect.utils.artifacts import check_checksum, write_artifact
+from snowflake.snowpark_connect.utils.artifacts import (
+    check_checksum,
+    write_artifact,
+    write_class_files_to_stage,
+)
 from snowflake.snowpark_connect.utils.cache import (
     df_cache_map_get,
     df_cache_map_pop,
@@ -249,7 +253,9 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
                     return proto_base.AnalyzePlanResponse(
                         session_id=request.session_id,
                         ddl_parse=proto_base.AnalyzePlanResponse.DDLParse(
-                            parsed=parse_ddl_string(request.ddl_parse.ddl_string)
+                            parsed=map_type_string_to_proto(
+                                request.ddl_parse.ddl_string
+                            )
                         ),
                     )
                 case "get_storage_level":
@@ -516,7 +522,13 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
         for name, data in cache_data.items():
             _try_handle_local_relation(name, bytes(data))
 
+        class_files: dict[str, str] = {}
         for (name, filepath) in filenames.items():
+            if name.endswith(".class"):
+                # name is <dir>/<package>/<class_name>
+                # we don't need the dir name, but require the package, so only remove dir
+                class_files[name.split("/", 1)[-1]] = filepath
+                continue
             session.file.put(
                 filepath,
                 session.get_session_stage(),
@@ -541,6 +553,9 @@ class SnowflakeConnectServicer(proto_base_grpc.SparkConnectServiceServicer):
             if not name.startswith("pyfiles"):
                 session._import_files.add(cached_name)
 
+        if class_files:
+            write_class_files_to_stage(session, class_files)
+
         return proto_base.AddArtifactsResponse(artifacts=list(response.values()))
 
     def ArtifactStatus(self, request, context):