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

snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -89,6 +89,12 @@ from snowflake.snowpark_connect.error.error_utils import attach_custom_error_cod
 from snowflake.snowpark_connect.expression.function_defaults import (
     inject_function_defaults,
 )
+from snowflake.snowpark_connect.expression.integral_types_support import (
+    apply_abs_overflow_with_ansi_check,
+    apply_arithmetic_overflow_with_ansi_check,
+    apply_unary_overflow_with_ansi_check,
+    get_integral_type_bounds,
+)
 from snowflake.snowpark_connect.expression.literal import get_literal_field_and_name
 from snowflake.snowpark_connect.expression.map_cast import (
     CAST_FUNCTIONS,
@@ -607,6 +613,7 @@ def map_unresolved_function(
                         overflow_possible,
                         global_config.spark_sql_ansi_enabled,
                         result_type,
+                        "multiply",
                     )
                 case (NullType(), NullType()):
                     result_type = DoubleType()
@@ -750,9 +757,17 @@ def map_unresolved_function(
                     result_type = _find_common_type(
                         [arg.typ for arg in snowpark_typed_args]
                     )
-                    result_exp = snowpark_args[0].cast(result_type) * snowpark_args[
-                        1
-                    ].cast(result_type)
+                    if isinstance(result_type, _IntegralType):
+                        raw_result = snowpark_args[0].cast(result_type) * snowpark_args[
+                            1
+                        ].cast(result_type)
+                        result_exp = apply_arithmetic_overflow_with_ansi_check(
+                            raw_result, result_type, spark_sql_ansi_enabled, "multiply"
+                        )
+                    else:
+                        result_exp = snowpark_args[0].cast(result_type) * snowpark_args[
+                            1
+                        ].cast(result_type)
                 case _:
                     exception = AnalysisException(
                         f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
@@ -1012,6 +1027,7 @@ def map_unresolved_function(
                         overflow_possible,
                         global_config.spark_sql_ansi_enabled,
                         result_type,
+                        "add",
                     )
 
         case "-":
@@ -1194,6 +1210,7 @@ def map_unresolved_function(
                         overflow_possible,
                         global_config.spark_sql_ansi_enabled,
                         result_type,
+                        "subtract",
                     )
 
         case "/":
@@ -1218,6 +1235,7 @@ def map_unresolved_function(
                         overflow_possible,
                         global_config.spark_sql_ansi_enabled,
                         result_type,
+                        "divide",
                     )
                 case (NullType(), NullType()):
                     result_type = DoubleType()
@@ -1471,6 +1489,11 @@ def map_unresolved_function(
                     snowpark_fn.cast(snowpark_args[0], DoubleType())
                 )
                 result_type = DoubleType()
+            elif isinstance(input_type, _IntegralType):
+                result_exp = apply_abs_overflow_with_ansi_check(
+                    snowpark_args[0], input_type, spark_sql_ansi_enabled
+                )
+                result_type = input_type
             else:
                 result_exp = snowpark_fn.abs(snowpark_args[0])
                 result_type = input_type
@@ -3764,7 +3787,12 @@ def map_unresolved_function(
                 snowpark_args[0].is_null(), snowpark_fn.lit(None)
             ).otherwise(snowpark_fn.cast(csv_result, result_type))
         case "from_json":
-            # TODO: support options.
+            # TODO: support options parameter.
+            # The options map (e.g., map('timestampFormat', 'dd/MM/yyyy')) is validated
+            # but not currently used. To implement:
+            # 1. Extract options from snowpark_args[2]
+            # 2. Pass format options to JSON parsing/coercion logic
+            # 3. Apply custom formats when casting timestamp/date fields
             if len(snowpark_args) > 2:
                 if not isinstance(snowpark_typed_args[2].typ, MapType):
                     exception = AnalysisException(
@@ -3792,6 +3820,29 @@ def map_unresolved_function(
                 logger.debug("Failed to parse datatype json string: %s", e)
                 result_type = map_type_string_to_snowpark_type(lit_schema)
 
+            # Validate that all MapTypes in the schema have StringType keys.
+            # JSON specification only supports string keys, so from_json cannot parse
+            # into MapType with non-string keys (e.g., IntegerType, LongType).
+            # Spark enforces this and raises INVALID_JSON_MAP_KEY_TYPE error.
+            def _validate_map_key_types(data_type: DataType) -> None:
+                """Recursively validate that all MapType instances have StringType keys."""
+                if isinstance(data_type, MapType):
+                    if not isinstance(data_type.key_type, StringType):
+                        exception = AnalysisException(
+                            f"[INVALID_JSON_MAP_KEY_TYPE] Input schema {lit_schema} can only contain STRING as a key type for a MAP."
+                        )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
+                    # Check the value type recursively
+                    _validate_map_key_types(data_type.value_type)
+                elif isinstance(data_type, ArrayType):
+                    _validate_map_key_types(data_type.element_type)
+                elif isinstance(data_type, StructType):
+                    for field in data_type.fields:
+                        _validate_map_key_types(field.datatype)
+
+            _validate_map_key_types(result_type)
+
             # if the result is a map, the column is named "entries"
             if isinstance(result_type, MapType):
                 spark_function_name = "entries"
@@ -3846,11 +3897,14 @@ def map_unresolved_function(
                 # let's optimistically assume that any simple type can be coerced to the expected type automatically
                 return snowpark_fn.lit(True)
 
-            # There is a known limitation in snowflake while casting semi structured data to structured data
-            # that if some keys are missing in value the cast would fail
-            # we need to make sure it has the same "shape" as the result_type.
-            # This function will construct an expression
-            # that will convert the parsed json to the expected type.
+            # Snowflake limitation: Casting semi-structured data to structured types fails
+            # if the source doesn't have the exact "shape" (e.g., missing struct fields).
+            # This function constructs an expression that coerces the parsed JSON to match
+            # the expected type structure, filling in NULLs for missing fields.
+            #
+            # For complex types (StructType, ArrayType, MapType), this recursively ensures
+            # nested structures match the schema. For MapType with complex values, it uses
+            # a pure SQL REDUCE approach to avoid UDF-in-lambda errors.
             def _coerce_to_type(
                 exp: Column, t: DataType, top_level: bool = True
             ) -> Column:
@@ -3873,13 +3927,15 @@ def map_unresolved_function(
                             snowpark_fn.as_object(exp).is_null(), snowpark_fn.lit(None)
                         ).otherwise(snowpark_fn.object_construct_keep_null(*key_values))
                 elif isinstance(t, ArrayType):
+                    # Handle array wrapping behavior for top-level structs
                     if top_level and isinstance(t.element_type, StructType):
-                        # Spark can still wrap a single value in an array if the internal type is a struct
+                        # Spark can wrap a single value in an array if the element type is a struct
                         arr_exp = snowpark_fn.to_array(exp)
                     else:
-                        # if it's not a struct, we can return null for any non-array values
+                        # For other types, return null for non-array values
                         arr_exp = snowpark_fn.as_array(exp)
-                    # adjust the parsed json to match the expected type so that we can cast it later
+
+                    # Get coercion SQL for the array element type using placeholder column "x"
                     analyzer = Session.get_active_session()._analyzer
                     fn_sql = analyzer.analyze(
                         _coerce_to_type(
@@ -3888,7 +3944,7 @@ def map_unresolved_function(
                         defaultdict(),
                     )
 
-                    # if there's even a single incorrect element, return null
+                    # Apply TRANSFORM to coerce each element, or return null if types don't match
                     return snowpark_fn.when(
                         _element_type_matches(arr_exp, t.element_type),
                         snowpark_fn.call_function(
@@ -3896,9 +3952,58 @@ def map_unresolved_function(
                         ),
                     ).otherwise(snowpark_fn.lit(None))
                 elif isinstance(t, MapType):
-                    return snowpark_fn.as_object(exp)
+                    obj_exp = snowpark_fn.as_object(exp)
+
+                    # If value type is simple (no nested complex types), no coercion needed
+                    if not isinstance(t.value_type, (StructType, ArrayType, MapType)):
+                        return obj_exp
+
+                    # For maps with complex value types, we need to coerce each value.
+                    # Strategy: Use pure SQL REDUCE with stateful accumulator to avoid:
+                    # 1. UDF-in-lambda errors (which break nested maps)
+                    # 2. Column scoping issues (outer columns aren't accessible in lambdas)
+                    #
+                    # The state is a 2-element array: [result_map, original_map]
+                    # This allows the lambda to access the original map's values while building the result.
+
+                    analyzer = Session.get_active_session()._analyzer
+
+                    # Get the coercion SQL for the value type using a placeholder column
+                    fn_sql = analyzer.analyze(
+                        _coerce_to_type(
+                            snowpark_fn.col("v"), t.value_type, False
+                        )._expression,
+                        defaultdict(),
+                    )
+
+                    # Replace placeholder "V" with reference to original map via state array
+                    # In lambda: state[1] = original_map, k = current_key
+                    fn_sql_with_value = fn_sql.replace(
+                        '"V"', "strip_null_value(GET(state[1], k))"
+                    )
+
+                    # Build REDUCE lambda: (state, k) -> [updated_result, original_map]
+                    lambda_expr = (
+                        f"(state, k) -> ARRAY_CONSTRUCT("
+                        f"object_insert(state[0], k, ({fn_sql_with_value})::variant, true), "
+                        f"state[1])"
+                    )
+
+                    # Execute REDUCE with initial state = [{}, original_map]
+                    reduce_result = snowpark_fn.call_function(
+                        "reduce",
+                        snowpark_fn.call_function("object_keys", obj_exp),
+                        snowpark_fn.array_construct(
+                            snowpark_fn.object_construct(),  # state[0]: empty result map
+                            obj_exp,  # state[1]: original map
+                        ),
+                        snowpark_fn.sql_expr(lambda_expr),
+                    )
+
+                    # Extract the result map (state[0]) from the final state
+                    return snowpark_fn.get(reduce_result, snowpark_fn.lit(0))
                 else:
-                    return exp
+                    return snowpark_fn.try_cast(snowpark_fn.to_varchar(exp), t)
 
             # Apply the coercion to handle invalid JSON (creates struct with NULL fields)
             coerced_exp = _coerce_to_type(result_exp, result_type)
@@ -5930,7 +6035,11 @@ def map_unresolved_function(
                 spark_function_name = f"(- {snowpark_arg_names[0]})"
             else:
                 spark_function_name = f"negative({snowpark_arg_names[0]})"
-            if (
+            if isinstance(arg_type, _IntegralType):
+                result_exp = apply_unary_overflow_with_ansi_check(
+                    snowpark_args[0], arg_type, spark_sql_ansi_enabled, "negative"
+                )
+            elif (
                 isinstance(arg_type, _NumericType)
                 or isinstance(arg_type, YearMonthIntervalType)
                 or isinstance(arg_type, DayTimeIntervalType)
@@ -8101,10 +8210,20 @@ def map_unresolved_function(
             else:
                 result_type = DoubleType()
 
-            result_exp = _resolve_aggregate_exp(
-                sum_fn(arg),
-                result_type,
-            )
+            if isinstance(input_type, _IntegralType) and not is_window_enabled():
+                raw_sum = sum_fn(arg)
+                wrapped_sum = apply_arithmetic_overflow_with_ansi_check(
+                    raw_sum, result_type, spark_sql_ansi_enabled, "add"
+                )
+                result_exp = _resolve_aggregate_exp(
+                    wrapped_sum,
+                    result_type,
+                )
+            else:
+                result_exp = _resolve_aggregate_exp(
+                    sum_fn(arg),
+                    result_type,
+                )
         case "tan":
             spark_function_name = f"TAN({snowpark_arg_names[0]})"
             result_exp = snowpark_fn.tan(snowpark_args[0])
@@ -8977,10 +9096,15 @@ def map_unresolved_function(
                         .otherwise(snowpark_args[0] + snowpark_args[1])
                     )
                 case _:
-                    result_exp = _try_arithmetic_helper(
+                    result_exp, result_type = _try_arithmetic_helper(
                         snowpark_typed_args, snowpark_args, 0
                     )
-                    result_exp = _type_with_typer(result_exp)
+                    if result_type is not None:
+                        result_exp = TypedColumn(
+                            result_exp, lambda rt=result_type: [rt]
+                        )
+                    else:
+                        result_exp = _type_with_typer(result_exp)
         case "try_aes_decrypt":
             result_exp = _aes_helper(
                 "TRY_DECRYPT",
@@ -9110,6 +9234,7 @@ def map_unresolved_function(
                         overflow_possible,
                         False,
                         result_type,
+                        "divide",
                     )
                 case (_NumericType(), _NumericType()):
                     result_exp = snowpark_fn.when(
@@ -9263,31 +9388,29 @@ def map_unresolved_function(
                             result_type = FloatType()
                         case _:
                             result_type = t
-                case (_IntegralType(), _IntegralType()):
-                    min_long = sys.maxsize + 1
-                    max_long = sys.maxsize
+                case (_IntegralType() as t1, _IntegralType() as t2):
+                    result_type = _find_common_type([t1, t2])
+                    min_val, max_val = get_integral_type_bounds(result_type)
 
-                    max_value = snowpark_fn.when(
-                        ((snowpark_args[0] > 0) & (snowpark_args[1] > 0))
-                        | ((snowpark_args[0] < 0) & (snowpark_args[1] < 0)),
-                        max_long,
-                    ).otherwise(min_long)
+                    same_sign = ((snowpark_args[0] > 0) & (snowpark_args[1] > 0)) | (
+                        (snowpark_args[0] < 0) & (snowpark_args[1] < 0)
+                    )
+                    bound = snowpark_fn.when(same_sign, max_val).otherwise(-min_val - 1)
 
                     result_exp = (
-                        # Multiplication by 0 must be handled separately, since division by 0 will throw an error.
                         snowpark_fn.when(
                             (snowpark_args[0] == 0) | (snowpark_args[1] == 0),
-                            snowpark_fn.lit(0),
+                            snowpark_fn.lit(0).cast(result_type),
                         )
-                        # We check for overflow by seeing if max or min divided by the right argument is greater than the
-                        # left argument.
                         .when(
                             snowpark_fn.abs(snowpark_args[0])
-                            > (max_value / snowpark_fn.abs(snowpark_args[1])),
+                            > (bound / snowpark_fn.abs(snowpark_args[1])),
                             snowpark_fn.lit(None),
-                        ).otherwise(snowpark_args[0] * snowpark_args[1])
+                        )
+                        .otherwise(
+                            (snowpark_args[0] * snowpark_args[1]).cast(result_type)
+                        )
                     )
-                    result_exp = _type_with_typer(result_exp)
                 case (
                     (DecimalType(), _IntegralType())
                     | (
@@ -9310,6 +9433,7 @@ def map_unresolved_function(
                         overflow_possible,
                         False,
                         result_type,
+                        "multiply",
                     )
                 case (_NumericType(), _NumericType()):
                     result_exp = snowpark_args[0] * snowpark_args[1]
@@ -9457,10 +9581,15 @@ def map_unresolved_function(
                         .otherwise(snowpark_args[0] - snowpark_args[1])
                     )
                 case _:
-                    result_exp = _try_arithmetic_helper(
+                    result_exp, result_type = _try_arithmetic_helper(
                         snowpark_typed_args, snowpark_args, 1
                     )
-                    result_exp = _type_with_typer(result_exp)
+                    if result_type is not None:
+                        result_exp = TypedColumn(
+                            result_exp, lambda rt=result_type: [rt]
+                        )
+                    else:
+                        result_exp = _type_with_typer(result_exp)
         case "try_to_number":
             try_to_number = snowpark_fn.function("try_to_number")
             precision, scale = resolve_to_number_precision_and_scale(exp)
@@ -11178,7 +11307,7 @@ def _try_sum_helper(
                 input_types=[arg_type],
             )
             # call the udaf
-            return _try_sum_int_udaf(col_name), arg_type
+            return _try_sum_int_udaf(col_name), LongType()
 
             # NOTE: We will never call this function with an IntegerType column and calculating_avg=True. Therefore,
             # we don't need to handle the case where calculating_avg=True here. The caller of this function will handle it.
@@ -11402,8 +11531,15 @@ def _arithmetic_operation(
     op: Callable[[Column, Column], Column],
     overflow_possible: bool,
     should_raise_on_overflow: bool,
-    target_type: DecimalType,
+    target_type: DataType,
+    operation_name: str,
 ) -> Column:
+    if isinstance(target_type, _IntegralType):
+        raw_result = op(arg1.col, arg2.col)
+        return apply_arithmetic_overflow_with_ansi_check(
+            raw_result, target_type, should_raise_on_overflow, operation_name
+        )
+
     def _cast_arg(tc: TypedColumn) -> Column:
         _, s = _get_type_precision(tc.typ)
         typ = (
@@ -11490,12 +11626,12 @@ def _get_decimal_division_result_type(p1, s1, p2, s2) -> tuple[DecimalType, bool
 
 def _try_arithmetic_helper(
     typed_args: List[TypedColumn], snowpark_args: List[Column], operation_type: int
-) -> Column:
+) -> tuple[Column, DataType | None]:
     # Constructs a Snowpark Column expression for a "try-style" arithmetic operation
     # (addition or subtraction, determined by `operation_type`) between two input columns.
     #
     # Key behavioral characteristics:
-    # 1. For **Integral inputs**: Explicitly checks for 64-bit overflow/underflow.
+    # 1. For **Integral inputs**: Explicitly checks for overflow/underflow at the result type boundaries.
     #    - BEHAVIOR: Returns a NULL literal if the operation would exceed these limits;
     #      otherwise, returns the result of the standard Snowpark `+` or `-`.
     #
@@ -11508,10 +11644,11 @@ def _try_arithmetic_helper(
     # Arithmetic operations involving **Boolean types** will raise an `AnalysisException`.
     # All other unhandled incompatible type combinations result in a NULL literal.
     # The function returns the resulting Snowpark Column expression.
-
     match (typed_args[0].typ, typed_args[1].typ):
-        case (_IntegralType(), _IntegralType()):
-            # For integer addition, overflow errors by default in Snowflake. We need it to return null.
+        case (_IntegralType() as t1, _IntegralType() as t2):
+            result_type = _find_common_type([t1, t2])
+            min_val, max_val = get_integral_type_bounds(result_type)
+
             if operation_type == 0:  # Addition
                 result_exp = (
                     snowpark_fn.when(
@@ -11519,20 +11656,20 @@ def _try_arithmetic_helper(
                         & (snowpark_args[1] > 0)
                         & (
                             snowpark_args[0]
-                            > snowpark_fn.lit(MAX_INT64) - snowpark_args[1]
+                            > snowpark_fn.lit(max_val) - snowpark_args[1]
                         ),
-                        snowpark_fn.lit(None),  # Overflow
+                        snowpark_fn.lit(None),
                     )
                     .when(
                         (snowpark_args[0] < 0)
                         & (snowpark_args[1] < 0)
                         & (
                             snowpark_args[0]
-                            < snowpark_fn.lit(MIN_INT64) - snowpark_args[1]
+                            < snowpark_fn.lit(min_val) - snowpark_args[1]
                         ),
-                        snowpark_fn.lit(None),  # Underflow
+                        snowpark_fn.lit(None),
                     )
-                    .otherwise(snowpark_args[0] + snowpark_args[1])
+                    .otherwise((snowpark_args[0] + snowpark_args[1]).cast(result_type))
                 )
             else:  # Subtraction
                 result_exp = (
@@ -11541,22 +11678,22 @@ def _try_arithmetic_helper(
                         & (snowpark_args[1] < 0)
                         & (
                             snowpark_args[0]
-                            > snowpark_fn.lit(MAX_INT64) + snowpark_args[1]
+                            > snowpark_fn.lit(max_val) + snowpark_args[1]
                         ),
-                        snowpark_fn.lit(None),  # Overflow
+                        snowpark_fn.lit(None),
                     )
                     .when(
                         (snowpark_args[0] < 0)
                         & (snowpark_args[1] > 0)
                         & (
                             snowpark_args[0]
-                            < snowpark_fn.lit(MIN_INT64) + snowpark_args[1]
+                            < snowpark_fn.lit(min_val) + snowpark_args[1]
                         ),
-                        snowpark_fn.lit(None),  # Underflow
+                        snowpark_fn.lit(None),
                     )
-                    .otherwise(snowpark_args[0] - snowpark_args[1])
+                    .otherwise((snowpark_args[0] - snowpark_args[1]).cast(result_type))
                 )
-            return result_exp
+            return result_exp, result_type
         case (DateType(), _) | (_, DateType()):
             arg1, arg2 = typed_args[0].typ, typed_args[1].typ
             # Valid input parameter types for try_add - DateType and _NumericType, _NumericType and DateType.
@@ -11577,22 +11714,28 @@ def _try_arithmetic_helper(
                     if isinstance(arg1, _IntegralType)
                     else snowpark_args
                 )
-                return _try_to_cast(
-                    "try_to_date",
-                    snowpark_fn.cast(snowpark_fn.date_add(*args), DateType()),
-                    args[0],
+                return (
+                    _try_to_cast(
+                        "try_to_date",
+                        snowpark_fn.cast(snowpark_fn.date_add(*args), DateType()),
+                        args[0],
+                    ),
+                    None,
                 )
             else:
                 if isinstance(arg1, DateType) and isinstance(arg2, _IntegralType):
-                    return _try_to_cast(
-                        "try_to_date",
-                        snowpark_fn.to_date(
-                            snowpark_fn.date_sub(snowpark_args[0], snowpark_args[1])
+                    return (
+                        _try_to_cast(
+                            "try_to_date",
+                            snowpark_fn.to_date(
+                                snowpark_fn.date_sub(snowpark_args[0], snowpark_args[1])
+                            ),
+                            snowpark_args[0],
                         ),
-                        snowpark_args[0],
+                        None,
                     )
                 elif isinstance(arg1, DateType) and isinstance(arg2, DateType):
-                    return snowpark_fn.daydiff(snowpark_args[0], snowpark_args[1])
+                    return snowpark_fn.daydiff(snowpark_args[0], snowpark_args[1]), None
                 else:
                     exception = AnalysisException(
                         '[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "date_sub(dt, sub)" due to data type mismatch: Parameter 1 requires the "DATE" type and parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type'
@@ -11609,12 +11752,16 @@ def _try_arithmetic_helper(
                 "try_add" if operation_type == 0 else "try_subtract",
             )
 
-            return _arithmetic_operation(
-                typed_args[0],
-                typed_args[1],
-                lambda x, y: x + y if operation_type == 0 else x - y,
-                overflow_possible,
-                False,
+            return (
+                _arithmetic_operation(
+                    typed_args[0],
+                    typed_args[1],
+                    lambda x, y: x + y if operation_type == 0 else x - y,
+                    overflow_possible,
+                    False,
+                    result_type,
+                    "add" if operation_type == 0 else "subtract",
+                ),
                 result_type,
             )
 
@@ -11622,11 +11769,12 @@ def _try_arithmetic_helper(
         # matches Spark and goes to inf.
         # Note that we already handle the int,int case above, hence it is okay to use the broader _numeric
         # below.
-        case (_NumericType(), _NumericType()):
+        case (_NumericType() as t1, _NumericType() as t2):
+            result_type = _find_common_type([t1, t2])
             if operation_type == 0:
-                return snowpark_args[0] + snowpark_args[1]
+                return snowpark_args[0] + snowpark_args[1], result_type
             else:
-                return snowpark_args[0] - snowpark_args[1]
+                return snowpark_args[0] - snowpark_args[1], result_type
         # String cases - try to convert to numeric
         case (
             (StringType(), _NumericType())
@@ -11642,12 +11790,12 @@ def _try_arithmetic_helper(
                 updated_args = _validate_numeric_args(
                     "try_add", typed_args, snowpark_args
                 )
-                return updated_args[0] + updated_args[1]
+                return updated_args[0] + updated_args[1], None
             else:
                 updated_args = _validate_numeric_args(
                     "try_subtract", typed_args, snowpark_args
                 )
-                return updated_args[0] - updated_args[1]
+                return updated_args[0] - updated_args[1], None
 
         case (BooleanType(), _) | (_, BooleanType()):
             exception = AnalysisException(
@@ -11657,7 +11805,7 @@ def _try_arithmetic_helper(
             raise exception
         case _:
             # Return NULL for incompatible types
-            return snowpark_fn.lit(None)
+            return snowpark_fn.lit(None), None
 
 
 def _get_add_sub_result_type(
@@ -11853,24 +12001,9 @@ def _get_literal_param_name(exp, arg_index: int, default_param_name: str):
 
 
 def _raise_error_helper(return_type: DataType, error_class=None):
-    error_class = (
-        f":{error_class.__name__}"
-        if error_class and hasattr(error_class, "__name__")
-        else ""
-    )
-
-    def _raise_fn(*msgs: Column) -> Column:
-        return snowpark_fn.cast(
-            snowpark_fn.abs(
-                snowpark_fn.concat(
-                    snowpark_fn.lit(f"[snowpark-connect-exception{error_class}]"),
-                    *(msg.try_cast(StringType()) for msg in msgs),
-                )
-            ).cast(StringType()),
-            return_type,
-        )
+    from snowflake.snowpark_connect.expression.error_utils import raise_error_helper
 
-    return _raise_fn
+    return raise_error_helper(return_type, error_class)
 
 
 def _divnull(dividend: Column, divisor: Column) -> Column: