Awesome06 commented on code in PR #55171:
URL: https://github.com/apache/arrow/pull/55171#discussion_r4440969362
##########
cpp/src/arrow/compute/kernels/scalar_compare_test.cc:
##########
@@ -1245,6 +1255,186 @@ TEST(TestBinaryViewCompareKernel, ArrayScalar) {
}
}
+TEST(TestBinaryViewCompareKernel, MixedStringTypes) {
+ // Array - Array (short inline strings <= 12 bytes)
+ auto str_arr = ArrayFromJSON(utf8(), R"(["a", "b", null, "d"])");
+ auto large_str_arr = ArrayFromJSON(large_utf8(), R"(["a", "b", null, "d"])");
+ auto view_arr = ArrayFromJSON(utf8_view(), R"(["a", "x", "c", null])");
+
+ CheckScalarBinary("equal", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("equal", view_arr, str_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("equal", large_str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("equal", view_arr, large_str_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+
+ CheckScalarBinary("not_equal", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[false, true, null, null]"));
+ CheckScalarBinary("less", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[false, true, null, null]"));
+ CheckScalarBinary("greater", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[false, false, null, null]"));
+
+ // Array - Array (long strings > 12 bytes testing out-of-line prefix +
buffer lookup)
+ auto long_str_arr = ArrayFromJSON(
+ utf8(), R"(["this_is_a_long_string_1", "this_is_a_long_string_2", null,
"short"])");
+ auto long_view_arr = ArrayFromJSON(
+ utf8_view(),
+ R"(["this_is_a_long_string_1", "this_is_a_different_long_string", "c",
null])");
+ CheckScalarBinary("equal", long_str_arr, long_view_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("equal", long_view_arr, long_str_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("not_equal", long_str_arr, long_view_arr,
+ ArrayFromJSON(boolean(), "[false, true, null, null]"));
+
+ // Empty arrays
+ auto empty_str = ArrayFromJSON(utf8(), "[]");
+ auto empty_view = ArrayFromJSON(utf8_view(), "[]");
+ CheckScalarBinary("equal", empty_str, empty_view, ArrayFromJSON(boolean(),
"[]"));
+ CheckScalarBinary("equal", empty_view, empty_str, ArrayFromJSON(boolean(),
"[]"));
+
+ // All-null arrays
+ auto null_str = ArrayFromJSON(utf8(), "[null, null]");
+ auto null_view = ArrayFromJSON(utf8_view(), "[null, null]");
+ CheckScalarBinary("equal", null_str, null_view,
+ ArrayFromJSON(boolean(), "[null, null]"));
+
+ // Sliced arrays
+ auto sliced_str = str_arr->Slice(1, 2);
+ auto sliced_view = view_arr->Slice(1, 2);
+ CheckScalarBinary("equal", sliced_str, sliced_view,
+ ArrayFromJSON(boolean(), "[false, null]"));
+ CheckScalarBinary("equal", sliced_view, sliced_str,
+ ArrayFromJSON(boolean(), "[false, null]"));
+
+ // Array - Scalar
+ auto scalar_str = ScalarFromJSON(utf8(), R"("b")");
+ auto scalar_view = ScalarFromJSON(utf8_view(), R"("b")");
+ auto scalar_large = ScalarFromJSON(large_utf8(), R"("b")");
+
+ auto arr_view = ArrayFromJSON(utf8_view(), R"(["a", "b", "c", null])");
+ auto arr_str = ArrayFromJSON(utf8(), R"(["a", "b", "c", null])");
+
+ CheckScalarBinary("equal", arr_view, scalar_str,
+ ArrayFromJSON(boolean(), "[false, true, false, null]"));
+ CheckScalarBinary("equal", scalar_str, arr_view,
+ ArrayFromJSON(boolean(), "[false, true, false, null]"));
+ CheckScalarBinary("equal", arr_str, scalar_view,
+ ArrayFromJSON(boolean(), "[false, true, false, null]"));
+ CheckScalarBinary("equal", scalar_view, arr_str,
+ ArrayFromJSON(boolean(), "[false, true, false, null]"));
+ CheckScalarBinary("equal", arr_view, scalar_large,
+ ArrayFromJSON(boolean(), "[false, true, false, null]"));
+
+ // Long scalar (> 12 bytes)
+ auto long_scalar_str = ScalarFromJSON(utf8(),
R"("this_is_a_long_string_1")");
+ auto long_scalar_view = ScalarFromJSON(utf8_view(),
R"("this_is_a_long_string_1")");
+ CheckScalarBinary("equal", long_view_arr, long_scalar_str,
+ ArrayFromJSON(boolean(), "[true, false, false, null]"));
+ CheckScalarBinary("equal", long_scalar_str, long_view_arr,
+ ArrayFromJSON(boolean(), "[true, false, false, null]"));
+ CheckScalarBinary("equal", long_str_arr, long_scalar_view,
+ ArrayFromJSON(boolean(), "[true, false, null, false]"));
+
+ // Asymmetric slice offsets
+ auto sliced_lhs = str_arr->Slice(1, 2); // ["b", null]
+ auto sliced_rhs = view_arr->Slice(2, 2); // ["c", null]
+ CheckScalarBinary("equal", sliced_lhs, sliced_rhs,
+ ArrayFromJSON(boolean(), "[false, null]"));
+
+ // Null scalar comparisons
+ auto null_scalar_str = MakeNullScalar(utf8());
+ auto null_scalar_view = MakeNullScalar(utf8_view());
+ CheckScalarBinary("equal", view_arr, null_scalar_str,
+ ArrayFromJSON(boolean(), "[null, null, null, null]"));
+ CheckScalarBinary("equal", str_arr, null_scalar_view,
+ ArrayFromJSON(boolean(), "[null, null, null, null]"));
+
+ // Embedded null bytes (\0) across inline (<=12B) and out-of-line (>12B)
views
+ auto null_byte_str =
+ ArrayFromJSON(utf8(), R"(["a\u0000b", "a\u0000x",
"long_prefix_\u0000_x"])");
+ auto null_byte_view =
+ ArrayFromJSON(utf8_view(), R"(["a\u0000b", "a\u0000y",
"long_prefix_\u0000_y"])");
+ CheckScalarBinary("equal", null_byte_str, null_byte_view,
+ ArrayFromJSON(boolean(), "[true, false, false]"));
+ CheckScalarBinary("less", null_byte_str, null_byte_view,
+ ArrayFromJSON(boolean(), "[false, true, true]"));
+
+ // Binary and BinaryView
+ auto bin_arr = ArrayFromJSON(binary(), R"(["a", "b", null, "d"])");
+ auto bin_view_arr = ArrayFromJSON(binary_view(), R"(["a", "x", "c", null])");
+ CheckScalarBinary("equal", bin_arr, bin_view_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+ CheckScalarBinary("equal", bin_view_arr, bin_arr,
+ ArrayFromJSON(boolean(), "[true, false, null, null]"));
+}
+
+TEST(TestBinaryViewCompareKernel, MixedStringTypeOrdering) {
+ // Verify less/greater with asymmetric string types (utf8 vs utf8_view)
+ auto str_arr = ArrayFromJSON(utf8(), R"(["apple", "banana", "cherry"])");
+ auto view_arr = ArrayFromJSON(utf8_view(), R"(["banana", "banana",
"apple"])");
+ CheckScalarBinary("less", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[true, false, false]"));
+ CheckScalarBinary("less", view_arr, str_arr,
+ ArrayFromJSON(boolean(), "[false, false, true]"));
+ CheckScalarBinary("greater", str_arr, view_arr,
+ ArrayFromJSON(boolean(), "[false, false, true]"));
+ CheckScalarBinary("greater", view_arr, str_arr,
+ ArrayFromJSON(boolean(), "[true, false, false]"));
+
+ // Verify 12-byte inline vs 13-byte out-of-line StringView boundary & 4-byte
prefix
+ // match
+ auto boundary_str =
+ ArrayFromJSON(utf8(), R"(["123456789012", "1234567890123",
"prefix_alpha"])");
+ auto boundary_view =
+ ArrayFromJSON(utf8_view(), R"(["1234567890123", "123456789012",
"prefix_omega"])");
+ CheckScalarBinary("less", boundary_str, boundary_view,
+ ArrayFromJSON(boolean(), "[true, false, true]"));
+ CheckScalarBinary("less", boundary_view, boundary_str,
+ ArrayFromJSON(boolean(), "[false, true, false]"));
+ CheckScalarBinary("equal", boundary_str, boundary_view,
+ ArrayFromJSON(boolean(), "[false, false, false]"));
+ CheckScalarBinary("not_equal", boundary_str, boundary_view,
+ ArrayFromJSON(boolean(), "[true, true, true]"));
+
+ // Dictionary-encoded string vs utf8_view (both directions)
+ auto dict_str =
+ ArrayFromJSON(dictionary(int32(), utf8()), R"(["apple", "banana",
null])");
+ auto plain_view = ArrayFromJSON(utf8_view(), R"(["apple", "cherry",
"banana"])");
+ CheckScalarBinary("equal", dict_str, plain_view,
+ ArrayFromJSON(boolean(), "[true, false, null]"));
+ CheckScalarBinary("equal", plain_view, dict_str,
+ ArrayFromJSON(boolean(), "[true, false, null]"));
+}
+
+TEST(TestCompareKernel, MixedDecimalScaleTests) {
Review Comment:
Removed. Defensive addition
##########
cpp/src/arrow/compute/expression_test.cc:
##########
@@ -2379,5 +2379,59 @@ TEST(Projection, AugmentWithKnownValues) {
}));
}
+TEST(Expression, DecimalComparisonDifferentScales) {
+ auto test_schema = arrow::schema({
+ field("a", decimal128(3, 2)),
+ field("b", decimal128(3, 1)),
+ });
+
+ auto batch = RecordBatchFromJSON(test_schema, R"([
+ {"a": "1.00", "b": "9.0"},
+ {"a": "9.00", "b": "1.0"}
+ ])");
+
+ // 1.00 < 9.0 -> true; 9.00 < 1.0 -> false
+ ASSERT_OK_AND_ASSIGN(auto less_expr,
+ less(field_ref("a"),
field_ref("b")).Bind(*test_schema));
+ ASSERT_OK_AND_ASSIGN(auto less_res,
+ ExecuteScalarExpression(less_expr, *test_schema,
batch));
+ AssertDatumsEqual(Datum(ArrayFromJSON(boolean(), "[true, false]")),
less_res);
+
+ // 1.00 <= 9.0 -> true; 9.00 <= 1.0 -> false
+ ASSERT_OK_AND_ASSIGN(auto le_expr,
+ less_equal(field_ref("a"),
field_ref("b")).Bind(*test_schema));
+ ASSERT_OK_AND_ASSIGN(auto le_res,
+ ExecuteScalarExpression(le_expr, *test_schema, batch));
+ AssertDatumsEqual(Datum(ArrayFromJSON(boolean(), "[true, false]")), le_res);
+
+ // Negative decimals with different scales
+ auto neg_batch = RecordBatchFromJSON(test_schema, R"([
+ {"a": "-1.00", "b": "-9.0"},
+ {"a": "-9.00", "b": "-1.0"}
+ ])");
+ // -1.00 < -9.0 -> false; -9.00 < -1.0 -> true
+ ASSERT_OK_AND_ASSIGN(auto neg_less_res,
+ ExecuteScalarExpression(less_expr, *test_schema,
neg_batch));
+ AssertDatumsEqual(Datum(ArrayFromJSON(boolean(), "[false, true]")),
neg_less_res);
+}
+
+TEST(Expression, MixedStringViewExpressionFlipping) {
Review Comment:
Removed. Defensive addition
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
