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

snowflake/snowpark_connect/utils/udf_cache.py

@@ -3,13 +3,9 @@
 #
 
 import functools
-import importlib.resources
-import tempfile
 import threading
 import typing
-import zipfile
 from collections.abc import Callable
-from pathlib import Path
 from types import ModuleType
 from typing import List, Optional, Tuple, Union
 
@@ -19,13 +15,15 @@ from snowflake.snowpark.functions import call_udf, udaf, udf, udtf
 from snowflake.snowpark.types import DataType, StructType
 from snowflake.snowpark_connect import tcm
 from snowflake.snowpark_connect.utils.telemetry import telemetry
+from snowflake.snowpark_connect.utils.upload_java_jar import (
+    JAVA_UDFS_JAR_NAME,
+    upload_java_udf_jar,
+)
 
 _lock = threading.RLock()
 
 _BUILTIN_UDF_PREFIX = "__SC_BUILTIN_"
 
-_JAVA_UDFS_JAR_NAME = "java_udfs-1.0-SNAPSHOT.jar"
-
 
 def init_builtin_udf_cache(session: Session) -> None:
     with _lock:
@@ -34,6 +32,7 @@ def init_builtin_udf_cache(session: Session) -> None:
         session._cached_udtfs = {}
         session._cached_java_udfs = {}
         session._cached_sql_udfs = {}
+        session._cached_sprocs = {}
 
 
 def _hash_types(types: list) -> str:
@@ -98,7 +97,11 @@ def cached_udaf(
         # Register the function outside the lock to avoid contention
         wrapped_func = udaf(
             udaf_type,
-            name=name,
+            name=[
+                Session.get_active_session().get_current_database(),
+                Session.get_active_session().get_current_schema(),
+                name,
+            ],
             return_type=return_type,
             input_types=input_types,
             imports=imports,
@@ -114,7 +117,7 @@ def cached_udaf(
 
     if class_type is None:
         raise ValueError(
-            "Type must be provided for cached_udaf. UDAF contains multiple functions hence it has to be represented by a type. Functions are not supported."
+            "[snowpark_connect::internal_error] Type must be provided for cached_udaf. UDAF contains multiple functions hence it has to be represented by a type. Functions are not supported."
         )
     else:
         # return udaf
@@ -155,7 +158,11 @@ def cached_udf(
         # but this will not cause any issues.
         wrapped_func = udf(
             _null_safe_wrapper,
-            name=name,
+            name=[
+                Session.get_active_session().get_current_database(),
+                Session.get_active_session().get_current_schema(),
+                name,
+            ],
             return_type=return_type,
             input_types=input_types,
             imports=imports,
@@ -205,7 +212,11 @@ def cached_udtf(
         # Register the function outside the lock to avoid contention
         wrapped_func = udtf(
             func,
-            name=name,
+            name=[
+                Session.get_active_session().get_current_database(),
+                Session.get_active_session().get_current_schema(),
+                name,
+            ],
             output_schema=output_schema,
             input_types=input_types,
             imports=imports,
@@ -306,11 +317,20 @@ def register_cached_sql_udf(
         )
 
         with _lock:
-            cache[function_name] = True
+            function_identifier = ".".join(
+                [
+                    Session.get_active_session().get_current_database(),
+                    Session.get_active_session().get_current_schema(),
+                    function_name,
+                ]
+            )
+            cache[function_name] = function_identifier
+    else:
+        function_identifier = cache[function_name]
 
     return functools.partial(
         call_udf,
-        function_name,
+        function_identifier,
     )
 
 
@@ -343,32 +363,7 @@ def register_cached_java_udf(
 
         if len(cache) == 0:
             # This is the first Java UDF being registered, so we need to upload the JAR with UDF definitions first
-            jar_path = ""
-            try:
-                jar_path = importlib.resources.files(
-                    "snowflake.snowpark_connect.resources"
-                ).joinpath(_JAVA_UDFS_JAR_NAME)
-            except NotADirectoryError:
-                # importlib.resource doesn't work in Stage Package method
-                zip_path = Path(__file__).parent.parent.parent.parent
-                jar_path_in_zip = (
-                    f"snowflake/snowpark_connect/resources/{_JAVA_UDFS_JAR_NAME}"
-                )
-                temp_dir = tempfile.gettempdir()
-
-                with zipfile.ZipFile(zip_path, "r") as zip_ref:
-                    if jar_path_in_zip not in zip_ref.namelist():
-                        raise FileNotFoundError(f"{jar_path_in_zip} not found")
-                    zip_ref.extract(jar_path_in_zip, temp_dir)
-
-                jar_path = f"{temp_dir}/{jar_path_in_zip}"
-
-            upload_result = session.file.put(str(jar_path), stage, overwrite=True)
-
-            if upload_result[0].status != "UPLOADED":
-                raise RuntimeError(
-                    f"Failed to upload JAR with UDF definitions to stage: {upload_result[0].message}"
-                )
+            upload_java_udf_jar(session)
 
         udf_is_cached = function_name in cache
 
@@ -378,15 +373,96 @@ def register_cached_java_udf(
             function_name,
             input_types,
             return_type,
-            [f"{stage}/{_JAVA_UDFS_JAR_NAME}"],
+            [f"{stage}/snowflake/snowpark_connect/resources/{JAVA_UDFS_JAR_NAME}"],
             java_handler,
             packages,
         )
 
         with _lock:
-            cache[function_name] = True
+            function_identifier = ".".join(
+                [
+                    Session.get_active_session().get_current_database(),
+                    Session.get_active_session().get_current_schema(),
+                    function_name,
+                ]
+            )
+            cache[function_name] = function_identifier
+    else:
+        function_identifier = cache[function_name]
 
     return functools.partial(
         call_udf,
-        function_name,
+        function_identifier,
+    )
+
+
+def register_cached_sproc(
+    sproc_body: str,
+    handler_name: str,
+    input_arg_types: list[str],
+    return_type: str = "STRING",
+    runtime_version: str = "3.11",
+    packages: list[str] | None = None,
+) -> str:
+    """
+    Register a cached stored procedure that persists across schema/database changes.
+
+    Args:
+        sproc_body: The Python code for the stored procedure
+        handler_name: Name of the handler function in the sproc_body
+        input_arg_types: List of SQL types for input arguments (e.g. ['STRING', 'STRING'])
+        return_type: SQL return type (default: 'STRING')
+        runtime_version: Python runtime version (default: '3.11')
+        packages: List of Python packages to include
+
+    Returns:
+        Fully qualified stored procedure name for calling
+    """
+    if packages is None:
+        packages = ["snowflake-snowpark-python"]
+
+    # Create a unique hash based on the procedure content and signature
+    content_hash = _hash_types(
+        [sproc_body, handler_name, return_type, runtime_version]
+        + input_arg_types
+        + packages
     )
+
+    # Generate unique procedure name with hash
+    sproc_name = f"{_BUILTIN_UDF_PREFIX}SPROC_{content_hash}"
+
+    with _lock:
+        session = Session.get_active_session()
+        cache = session._cached_sprocs
+
+        # Create fully qualified name with current database and schema
+        fully_qualified_name = ".".join(
+            [session.get_current_database(), session.get_current_schema(), sproc_name]
+        )
+
+        if sproc_name in cache:
+            return cache[sproc_name]
+
+    args_str = ",".join(
+        f"arg{idx} {type_}" for idx, type_ in enumerate(input_arg_types)
+    )
+    packages_str = ",".join(f"'{pkg}'" for pkg in packages)
+
+    session.sql(
+        f"""
+        CREATE OR REPLACE TEMPORARY PROCEDURE {sproc_name}({args_str})
+        RETURNS {return_type}
+        LANGUAGE PYTHON
+        RUNTIME_VERSION = '{runtime_version}'
+        PACKAGES = ({packages_str})
+        HANDLER = '{handler_name}'
+        AS $$
+{sproc_body}
+$$
+    """
+    ).collect()
+
+    with _lock:
+        cache[sproc_name] = fully_qualified_name
+
+    return fully_qualified_name

snowflake/snowpark_connect/utils/udf_helper.py

@@ -14,14 +14,20 @@ from pyspark.errors.exceptions.base import AnalysisException
 import snowflake.snowpark.functions as snowpark_fn
 import snowflake.snowpark_connect.tcm as tcm
 import snowflake.snowpark_connect.utils.udf_utils as udf_utils
-from snowflake.snowpark import Column, Session
+from snowflake.snowpark import Session
 from snowflake.snowpark.types import DataType, _parse_datatype_json_value
 from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
 from snowflake.snowpark_connect.config import global_config
+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 (
     map_single_column_expression,
 )
+from snowflake.snowpark_connect.expression.map_unresolved_star import (
+    map_unresolved_star_as_single_column,
+)
 from snowflake.snowpark_connect.expression.typer import ExpressionTyper
+from snowflake.snowpark_connect.typed_column import TypedColumn
 from snowflake.snowpark_connect.utils.context import (
     get_is_aggregate_function,
     get_is_evaluating_join_condition,
@@ -38,6 +44,7 @@ class SnowparkUDF(NamedTuple):
     return_type: DataType
     input_types: list[DataType]
     original_return_type: DataType | None
+    cast_to_original_return_type: bool = False
 
 
 def require_creating_udf_in_sproc(
@@ -184,6 +191,7 @@ def parse_return_type(return_type_json_str) -> Optional[DataType]:
 
 
 def create(session, called_from, return_type_json_str, input_types_json_str, input_column_names_json_str, udf_name, replace, udf_packages, udf_imports, b64_str, original_return_type):
+    session._use_scoped_temp_objects = False
     import snowflake.snowpark.context as context
     context._use_structured_type_semantics = True
     context._is_snowpark_connect_compatible_mode = True
@@ -227,25 +235,15 @@ def _check_supported_udf(
         case "python_udf":
             pass
         case "java_udf":
-            from snowflake.snowpark_connect.utils.session import (
-                get_or_create_snowpark_session,
-            )
-
-            session = get_or_create_snowpark_session()
-            if udf_proto.java_udf.class_name not in session._cached_java_udfs:
-                raise AnalysisException(
-                    f"Can not load class {udf_proto.java_udf.class_name}"
-                )
-            else:
-                raise ValueError(
-                    "Function type java_udf not supported for common inline user-defined function"
-                )
+            pass
         case "scalar_scala_udf":
             pass
         case _ as function_type:
-            raise ValueError(
+            exception = ValueError(
                 f"Function type {function_type} not supported for common inline user-defined function"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
 
 
 def _aggregate_function_check(
@@ -253,9 +251,11 @@ def _aggregate_function_check(
 ):
     name, is_aggregate_function = get_is_aggregate_function()
     if not udf_proto.deterministic and name != "default" and is_aggregate_function:
-        raise AnalysisException(
+        exception = AnalysisException(
             f"[AGGREGATE_FUNCTION_WITH_NONDETERMINISTIC_EXPRESSION] Non-deterministic expression {name}({udf_proto.function_name}) should not appear in the arguments of an aggregate function."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+        raise exception
 
 
 def _join_checks(snowpark_udf_arg_names: list[str]):
@@ -282,49 +282,51 @@ def _join_checks(snowpark_udf_arg_names: list[str]):
             and is_left_evaluable
             and is_right_evaluable
         ):
-            raise AnalysisException(
+            exception = AnalysisException(
                 f"Detected implicit cartesian product for {is_evaluating_join_condition[0]} join between logical plans. \n"
                 f"Join condition is missing or trivial. \n"
                 f"Either: use the CROSS JOIN syntax to allow cartesian products between those relations, or; "
                 f"enable implicit cartesian products by setting the configuration variable spark.sql.crossJoin.enabled=True."
             )
+            attach_custom_error_code(exception, ErrorCodes.INVALID_OPERATION)
+            raise exception
         if (
             is_evaluating_join_condition[0] != "INNER"
             and is_evaluating_join_condition[1]
             and is_left_evaluable
             and is_right_evaluable
         ):
-            raise AnalysisException(
+            exception = AnalysisException(
                 f"[UNSUPPORTED_FEATURE.PYTHON_UDF_IN_ON_CLAUSE] The feature is not supported: "
                 f"Python UDF in the ON clause of a {is_evaluating_join_condition[0]} JOIN. "
                 f"In case of an INNNER JOIN consider rewriting to a CROSS JOIN with a WHERE clause."
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
 
 
 def infer_snowpark_arguments(
     udf_proto: expressions_proto.CommonInlineUserDefinedFunction,
     column_mapping: ColumnNameMap,
     typer: ExpressionTyper,
-) -> tuple[list[str], list[Column]]:
-    snowpark_udf_args: list[Column] = []
+) -> tuple[list[str], list[TypedColumn]]:
+    snowpark_udf_args: list[TypedColumn] = []
     snowpark_udf_arg_names: list[str] = []
     for arg_exp in udf_proto.arguments:
-        (
-            snowpark_udf_arg_name,
-            snowpark_udf_arg,
-        ) = map_single_column_expression(arg_exp, column_mapping, typer)
-        snowpark_udf_arg = snowpark_udf_arg.col
-        snowpark_udf_args.append(snowpark_udf_arg)
-        snowpark_udf_arg_names.append(snowpark_udf_arg_name)
+        # Handle unresolved_star expressions specially
+        if arg_exp.HasField("unresolved_star"):
+            # Use map_unresolved_star_as_struct to expand star into a single combined column
+            spark_name, typed_column = map_unresolved_star_as_single_column(
+                arg_exp, column_mapping, typer
+            )
+            snowpark_udf_args.append(typed_column)
+            snowpark_udf_arg_names.append(spark_name)
+        else:
+            (
+                snowpark_udf_arg_name,
+                snowpark_udf_arg,
+            ) = map_single_column_expression(arg_exp, column_mapping, typer)
+            snowpark_udf_args.append(snowpark_udf_arg)
+            snowpark_udf_arg_names.append(snowpark_udf_arg_name)
     _join_checks(snowpark_udf_arg_names)
     return snowpark_udf_arg_names, snowpark_udf_args
-
-
-def gen_input_types(
-    snowpark_udf_args: list[Column],
-    typer: ExpressionTyper,
-):
-    input_types = []
-    for udf_arg in snowpark_udf_args:
-        input_types.extend(typer.type(udf_arg))
-    return input_types

snowflake/snowpark_connect/utils/udf_utils.py

@@ -103,7 +103,7 @@ class ProcessCommonInlineUserDefinedFunction:
                 )
             case _:
                 raise ValueError(
-                    f"Function type {self._function_type} not supported for common inline user-defined function"
+                    f"[snowpark_connect::unsupported_operation] Function type {self._function_type} not supported for common inline user-defined function"
                 )
 
     @property
@@ -112,7 +112,7 @@ class ProcessCommonInlineUserDefinedFunction:
             return self._snowpark_udf_args
         else:
             raise ValueError(
-                "Column mapping is not provided, cannot get snowpark udf args"
+                "[snowpark_connect::internal_error] Column mapping is not provided, cannot get snowpark udf args"
             )
 
     @property
@@ -121,7 +121,7 @@ class ProcessCommonInlineUserDefinedFunction:
             return self._snowpark_udf_arg_names
         else:
             raise ValueError(
-                "Column mapping is not provided, cannot get snowpark udf arg names"
+                "[snowpark_connect::internal_error] Column mapping is not provided, cannot get snowpark udf arg names"
             )
 
     def _create_python_udf(self):
@@ -148,7 +148,12 @@ class ProcessCommonInlineUserDefinedFunction:
 
             # Change directory to the one containing the UDF imported files
             import_path = sys._xoptions["snowflake_import_directory"]
-            tmp_path = f"/tmp/sas-{os.getpid()}"
+            if os.name == "nt":
+                import tempfile
+
+                tmp_path = os.path.join(tempfile.gettempdir(), f"sas-{os.getpid()}")
+            else:
+                tmp_path = f"/tmp/sas-{os.getpid()}"
             os.makedirs(tmp_path, exist_ok=True)
             os.chdir(tmp_path)
             shutil.copytree(import_path, tmp_path, dirs_exist_ok=True)
@@ -176,14 +181,6 @@ class ProcessCommonInlineUserDefinedFunction:
                         tar_ref.extractall(archive[: -len(".archive")])
                 os.remove(archive)
 
-        def callable_func(*args, **kwargs):
-            import_staged_files()
-            return original_callable(*args, **kwargs)
-
-        callable_func.__signature__ = inspect.signature(original_callable)
-        if hasattr(original_callable, "__annotations__"):
-            callable_func.__annotations__ = original_callable.__annotations__
-
         if self._udf_packages:
             packages = [p.strip() for p in self._udf_packages.strip("[]").split(",")]
         else:
@@ -193,13 +190,109 @@ class ProcessCommonInlineUserDefinedFunction:
         else:
             imports = []
 
+        def callable_func(*args, **kwargs):
+            if imports:
+                import_staged_files()
+            return original_callable(*args, **kwargs)
+
+        callable_func.__signature__ = inspect.signature(original_callable)
+        if hasattr(original_callable, "__annotations__"):
+            callable_func.__annotations__ = original_callable.__annotations__
+
         update_none_input_types()
 
+        struct_positions = [
+            i
+            for i, t in enumerate(self._input_types or [])
+            if isinstance(t, StructType)
+        ]
+
+        if struct_positions:
+
+            class StructRowProxy:
+                """Row-like object supporting positional and named access for PySpark compatibility."""
+
+                def __init__(self, fields, values) -> None:
+                    self._fields = fields
+                    self._values = values
+                    self._field_to_index = {field: i for i, field in enumerate(fields)}
+
+                def __getitem__(self, key):
+                    if isinstance(key, int):
+                        return self._values[key]
+                    elif isinstance(key, str):
+                        if key in self._field_to_index:
+                            return self._values[self._field_to_index[key]]
+                        raise KeyError(f"Field '{key}' not found in struct")
+                    else:
+                        raise TypeError(f"Invalid key type: {type(key)}")
+
+                def __getattr__(self, name):
+                    if name.startswith("_"):
+                        raise AttributeError(f"Attribute '{name}' not found")
+                    if name in self._field_to_index:
+                        return self._values[self._field_to_index[name]]
+                    raise AttributeError(f"Attribute '{name}' not found")
+
+                def __len__(self):
+                    return len(self._values)
+
+                def __iter__(self):
+                    return iter(self._values)
+
+                def __repr__(self):
+                    field_values = [
+                        f"{field}={repr(value)}"
+                        for field, value in zip(self._fields, self._values)
+                    ]
+                    return f"Row({', '.join(field_values)})"
+
+                def asDict(self):
+                    """Convert to dict (like PySpark Row.asDict())."""
+                    return dict(zip(self._fields, self._values))
+
+            def convert_to_row(arg):
+                """Convert dict to StructRowProxy. Only called for struct positions."""
+                if isinstance(arg, dict) and arg:
+                    fields = list(arg.keys())
+                    values = [arg[k] for k in fields]
+                    return StructRowProxy(fields, values)
+                return arg
+
+            def convert_from_row(result):
+                """Convert StructRowProxy back to dict for serialization."""
+                if isinstance(result, StructRowProxy):
+                    return result.asDict()
+                return result
+
+        def struct_input_wrapper(*args, **kwargs):
+            if struct_positions:
+                processed_args = []
+                for i, arg in enumerate(args):
+                    if i in struct_positions:
+                        processed_args.append(convert_to_row(arg))
+                    else:
+                        processed_args.append(arg)
+
+                processed_kwargs = {k: convert_to_row(v) for k, v in kwargs.items()}
+                result = callable_func(*tuple(processed_args), **processed_kwargs)
+                # Convert any StructRowProxy in return value back to dict for serialization
+                return convert_from_row(result)
+            return callable_func(*args, **kwargs)
+
         needs_struct_conversion = isinstance(self._original_return_type, StructType)
 
+        # Use callable_func directly when there are no struct inputs to avoid closure issues.
+        # struct_input_wrapper captures convert_to_row in its closure, but convert_to_row is only
+        # defined when struct_positions is truthy. Cloudpickle serializes all closure variables,
+        # so using struct_input_wrapper without struct positions would fail during serialization.
+        updated_callable_func = (
+            struct_input_wrapper if struct_positions else callable_func
+        )
+
         if not needs_struct_conversion:
             return snowpark_fn.udf(
-                create_null_safe_wrapper(callable_func),
+                create_null_safe_wrapper(updated_callable_func),
                 return_type=self._return_type,
                 input_types=self._input_types,
                 name=self._udf_name,
@@ -225,7 +318,21 @@ class ProcessCommonInlineUserDefinedFunction:
         field_names = [field.name for field in self._original_return_type.fields]
 
         def struct_wrapper(*args):
+            if struct_positions:
+                processed_args = []
+                for i, arg in enumerate(args):
+                    if i in struct_positions:
+                        processed_args.append(convert_to_row(arg))
+                    else:
+                        processed_args.append(arg)
+                args = tuple(processed_args)
+
             result = callable_func(*args)
+
+            # Convert StructRowProxy back to dict for serialization
+            if struct_positions:
+                result = convert_from_row(result)
+
             if isinstance(result, (tuple, list)):
                 # Convert tuple/list to dict using struct field names
                 if len(result) == len(field_names):
@@ -283,6 +390,18 @@ class ProcessCommonInlineUserDefinedFunction:
             case "python_udf":
                 return self._create_python_udf()
             case "scalar_scala_udf":
+                from snowflake.snowpark_connect.utils.context import (
+                    get_is_aggregate_function,
+                )
+
+                name, is_aggregate_function = get_is_aggregate_function()
+                if is_aggregate_function and name.lower() == "reduce":
+                    # Handling of Scala Reduce function requires usage of Java UDAF
+                    from snowflake.snowpark_connect.utils.java_udaf_utils import (
+                        create_java_udaf_for_reduce_scala_function,
+                    )
+
+                    return create_java_udaf_for_reduce_scala_function(self)
                 from snowflake.snowpark_connect.utils.scala_udf_utils import (
                     create_scala_udf,
                 )
@@ -290,5 +409,5 @@ class ProcessCommonInlineUserDefinedFunction:
                 return create_scala_udf(self)
             case _:
                 raise ValueError(
-                    f"Function type {self._function_type} not supported for common inline user-defined function"
+                    f"[snowpark_connect::unsupported_operation] Function type {self._function_type} not supported for common inline user-defined function"
                 )

snowflake/snowpark_connect/utils/udtf_helper.py

@@ -16,6 +16,8 @@ import snowflake.snowpark_connect.tcm as tcm
 from snowflake import snowpark
 from snowflake.snowpark._internal.analyzer.analyzer_utils import unquote_if_quoted
 from snowflake.snowpark.types import DataType, StructType, _parse_datatype_json_value
+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.type_mapping import proto_to_snowpark_type
 from snowflake.snowpark_connect.utils import pandas_udtf_utils, udtf_utils
 from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
@@ -37,7 +39,9 @@ def udtf_check(
     udtf_proto: relation_proto.CommonInlineUserDefinedTableFunction,
 ) -> None:
     if udtf_proto.WhichOneof("function") != "python_udtf":
-        raise ValueError(f"Not python udtf {udtf_proto.function}")
+        exception = ValueError(f"Not python udtf {udtf_proto.function}")
+        attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+        raise exception
 
 
 def require_creating_udtf_in_sproc(
@@ -149,6 +153,7 @@ def parse_types(types_json_str) -> Optional[list[DataType]]:
     return json.loads(types_json_str)
 
 def create(session, b64_str, expected_types_json_str, output_schema_json_str, packages, imports, is_arrow_enabled, is_spark_compatible_udtf_mode_enabled, called_from):
+    session._use_scoped_temp_objects = False
     import snowflake.snowpark.context as context
     context._use_structured_type_semantics = True
     context._is_snowpark_connect_compatible_mode = True
@@ -253,6 +258,7 @@ from snowflake.snowpark.types import _parse_datatype_json_value
 {inline_udtf_utils_py_code}
 
 def create(session, b64_str, spark_column_names_json_str, input_schema_json_str, return_schema_json_str):
+    session._use_scoped_temp_objects = False
     import snowflake.snowpark.context as context
     context._use_structured_type_semantics = True
     context._is_snowpark_connect_compatible_mode = True
@@ -326,6 +332,7 @@ from snowflake.snowpark.types import _parse_datatype_json_value
 from pyspark.serializers import CloudPickleSerializer
 
 def create(session, func_info_json):
+    session._use_scoped_temp_objects = False
     import snowflake.snowpark.context as context
     context._use_structured_type_semantics = True
     context._is_snowpark_connect_compatible_mode = True