This is an automated email from the ASF dual-hosted git repository.
airborne pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 7b9b42b76a1 [test](like) add more ut for like function (#54225)
7b9b42b76a1 is described below
commit 7b9b42b76a1c28d67f9b505e15f59bb30c4bcb68
Author: airborne12 <[email protected]>
AuthorDate: Mon Aug 4 10:27:05 2025 +0800
[test](like) add more ut for like function (#54225)
---
be/test/vec/function/function_like_test.cpp | 518 ++++++++++++++++++++++++++++
1 file changed, 518 insertions(+)
diff --git a/be/test/vec/function/function_like_test.cpp
b/be/test/vec/function/function_like_test.cpp
index 182d3f1e8ec..00a7e0bf157 100644
--- a/be/test/vec/function/function_like_test.cpp
+++ b/be/test/vec/function/function_like_test.cpp
@@ -21,10 +21,13 @@
#include "function_test_util.h"
#include "gtest/gtest_pred_impl.h"
#include "testutil/any_type.h"
+#include "vec/columns/column_string.h"
+#include "vec/columns/column_vector.h"
#include "vec/core/types.h"
#include "vec/data_types/data_type_nullable.h"
#include "vec/data_types/data_type_number.h"
#include "vec/data_types/data_type_string.h"
+#include "vec/functions/like.h"
namespace doris::vectorized {
@@ -307,4 +310,519 @@ TEST(FunctionLikeTest, regexp_replace_one) {
}
}
+// Enhanced tests for better coverage
+
+TEST(FunctionLikeTest, pattern_optimization_allpass) {
+ std::string func_name = "like";
+
+ // Test allpass patterns that should match everything
+ DataSet data_set = {{{std::string("any_string"), std::string("%")},
uint8_t(1)},
+ {{std::string(""), std::string("%")}, uint8_t(1)},
+ {{std::string("test"), std::string("%%")}, uint8_t(1)},
+ {{std::string("multi line\ntext"),
std::string("%%%")}, uint8_t(1)},
+ {{std::string("special@#$%chars"), std::string("%")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, pattern_optimization_equals) {
+ std::string func_name = "like";
+
+ // Test patterns that should be optimized to exact equals
+ DataSet data_set = {
+ {{std::string("exact_match"), std::string("exact_match")},
uint8_t(1)},
+ {{std::string("exact_match"), std::string("different")},
uint8_t(0)},
+ {{std::string(""), std::string("")}, uint8_t(1)},
+ {{std::string("test"), std::string("test")}, uint8_t(1)},
+ {{std::string("Test"), std::string("test")}, uint8_t(0)}, // case
sensitive
+ {{std::string("with_underscore"), std::string("with_underscore")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, pattern_optimization_starts_with) {
+ std::string func_name = "like";
+
+ // Test patterns that should be optimized to starts_with
+ DataSet data_set = {{{std::string("prefix_test"), std::string("prefix%")},
uint8_t(1)},
+ {{std::string("different_start"),
std::string("prefix%")}, uint8_t(0)},
+ {{std::string("p"), std::string("prefix%")},
uint8_t(0)},
+ {{std::string("prefix"), std::string("prefix%")},
uint8_t(1)},
+ {{std::string("prefixABC"), std::string("prefix%")},
uint8_t(1)},
+ {{std::string(""), std::string("nonempty%")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, pattern_optimization_ends_with) {
+ std::string func_name = "like";
+
+ // Test patterns that should be optimized to ends_with
+ DataSet data_set = {{{std::string("test_suffix"), std::string("%suffix")},
uint8_t(1)},
+ {{std::string("different_end"),
std::string("%suffix")}, uint8_t(0)},
+ {{std::string("s"), std::string("%suffix")},
uint8_t(0)},
+ {{std::string("suffix"), std::string("%suffix")},
uint8_t(1)},
+ {{std::string("ABCsuffix"), std::string("%suffix")},
uint8_t(1)},
+ {{std::string(""), std::string("%nonempty")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, pattern_optimization_substring) {
+ std::string func_name = "like";
+
+ // Test patterns that should be optimized to substring search
+ DataSet data_set = {
+ {{std::string("prefix_middle_suffix"), std::string("%middle%")},
uint8_t(1)},
+ {{std::string("no_match_here"), std::string("%middle%")},
uint8_t(0)},
+ {{std::string("middle"), std::string("%middle%")}, uint8_t(1)},
+ {{std::string("middlepart"), std::string("%middle%")}, uint8_t(1)},
+ {{std::string("partmiddle"), std::string("%middle%")}, uint8_t(1)},
+ {{std::string(""), std::string("%nonempty%")}, uint8_t(0)},
+ {{std::string("anything"), std::string("%%")}, uint8_t(1)} //
empty substring
+ };
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, complex_patterns) {
+ std::string func_name = "like";
+
+ // Test complex patterns that require full regex processing
+ DataSet data_set = {
+ {{std::string("abcdef"), std::string("a_c%")}, uint8_t(1)},
+ {{std::string("aXcYZ"), std::string("a_c%")}, uint8_t(1)},
+ {{std::string("ac"), std::string("a_c%")}, uint8_t(0)}, // too
short
+ {{std::string("abdef"), std::string("a_c%")}, uint8_t(0)}, // no
'c' in right position
+ {{std::string("test123"), std::string("test___")}, uint8_t(1)},
+ {{std::string("test12"), std::string("test___")}, uint8_t(0)},
// too short
+ {{std::string("test1234"), std::string("test___")}, uint8_t(0)},
// too long
+ {{std::string("multiple_words"), std::string("%_words")},
uint8_t(1)},
+ {{std::string("words"), std::string("%_words")},
+ uint8_t(0)} // need at least one char before
+ };
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, escape_characters_advanced) {
+ std::string func_name = "like";
+
+ // Test advanced escape character scenarios
+ DataSet data_set = {
+ // Escaped percent and underscore
+ {{std::string("50%"), std::string("50\\%")}, uint8_t(1)},
+ {{std::string("50percent"), std::string("50\\%")}, uint8_t(0)},
+ {{std::string("test_file"), std::string("test\\_file")},
uint8_t(1)},
+ {{std::string("testXfile"), std::string("test\\_file")},
uint8_t(0)},
+
+ // Double escaping
+ {{std::string("test\\file"), std::string("test\\\\file")},
uint8_t(1)},
+ {{std::string("testfile"), std::string("test\\\\file")},
uint8_t(0)},
+
+ // Mixed patterns with escapes
+ {{std::string(R"(path\to_file.txt)"),
std::string(R"(path\\to\_file%)")}, uint8_t(1)},
+ {{std::string(R"(path\toXfile.txt)"),
std::string(R"(path\\to\_file%)")}, uint8_t(0)},
+
+ // Edge cases
+ {{std::string("\\"), std::string("\\\\")}, uint8_t(1)},
+ {{std::string("_"), std::string("\\_")}, uint8_t(1)},
+ {{std::string("%"), std::string("\\%")}, uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, vector_patterns) {
+ std::string func_name = "like";
+
+ // Test with varying patterns (not constant)
+ DataSet data_set = {{{std::string("test1"), std::string("test%")},
uint8_t(1)},
+ {{std::string("example"), std::string("%ample")},
uint8_t(1)},
+ {{std::string("middle"), std::string("%dd%")},
uint8_t(1)},
+ {{std::string("exact"), std::string("exact")},
uint8_t(1)},
+ {{std::string("nomatch"), std::string("different")},
uint8_t(0)}};
+
+ // Both arguments are variables (not constant)
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, edge_cases_and_boundaries) {
+ std::string func_name = "like";
+
+ DataSet data_set = {
+ // Empty strings
+ {{std::string(""), std::string("")}, uint8_t(1)},
+ {{std::string(""), std::string("%")}, uint8_t(1)},
+ {{std::string("nonempty"), std::string("")}, uint8_t(0)},
+
+ // Very long strings
+ {{std::string(1000, 'a'), std::string("%a%")}, uint8_t(1)},
+ {{std::string(1000, 'a'), std::string("%b%")}, uint8_t(0)},
+
+ // Unicode and special characters
+ {{std::string("测试文本"), std::string("%试%")}, uint8_t(1)},
+ {{std::string("测试文本"), std::string("%不存在%")}, uint8_t(0)},
+ {{std::string("tab\there"), std::string("%\t%")}, uint8_t(1)},
+ {{std::string("newline\nhere"), std::string("%\n%")}, uint8_t(1)},
+
+ // Multiple wildcards
+ {{std::string("abcdef"), std::string("a%c%f")}, uint8_t(1)},
+ {{std::string("abcdef"), std::string("a%c%g")}, uint8_t(0)},
+ {{std::string("abcdef"), std::string("a_c_e_")}, uint8_t(1)},
+ {{std::string("abcde"), std::string("a_c_e_")}, uint8_t(0)} // too
short
+ };
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+TEST(FunctionLikeTest, regexp_optimization_allpass) {
+ std::string func_name = "regexp";
+
+ // Test regex patterns that match everything
+ DataSet data_set = {{{std::string("any_string"), std::string(".*")},
uint8_t(1)},
+ {{std::string(""), std::string(".*")}, uint8_t(1)},
+ {{std::string("test"), std::string(".*.*")},
uint8_t(1)},
+ {{std::string("multi line\ntext"),
std::string(".*.*.*")}, uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+TEST(FunctionLikeTest, regexp_optimization_equals) {
+ std::string func_name = "regexp";
+
+ // Test regex patterns that should be optimized to exact equals
+ DataSet data_set = {
+ {{std::string("exact_match"), std::string("^exact_match$")},
uint8_t(1)},
+ {{std::string("exact_match"), std::string("^different$")},
uint8_t(0)},
+ {{std::string(""), std::string("^$")}, uint8_t(1)},
+ {{std::string("test"), std::string("^test$")}, uint8_t(1)},
+ {{std::string("Test"), std::string("^test$")}, uint8_t(0)} // case
sensitive
+ };
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+TEST(FunctionLikeTest, regexp_optimization_starts_with) {
+ std::string func_name = "regexp";
+
+ // Test regex patterns that should be optimized to starts_with
+ DataSet data_set = {{{std::string("prefix_test"),
std::string("^prefix.*")}, uint8_t(1)},
+ {{std::string("different_start"),
std::string("^prefix.*")}, uint8_t(0)},
+ {{std::string("p"), std::string("^prefix.*")},
uint8_t(0)},
+ {{std::string("prefix"), std::string("^prefix.*")},
uint8_t(1)},
+ {{std::string("prefixABC"), std::string("^prefix.*")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+TEST(FunctionLikeTest, regexp_optimization_ends_with) {
+ std::string func_name = "regexp";
+
+ // Test regex patterns that should be optimized to ends_with
+ DataSet data_set = {{{std::string("test_suffix"),
std::string(".*suffix$")}, uint8_t(1)},
+ {{std::string("different_end"),
std::string(".*suffix$")}, uint8_t(0)},
+ {{std::string("s"), std::string(".*suffix$")},
uint8_t(0)},
+ {{std::string("suffix"), std::string(".*suffix$")},
uint8_t(1)},
+ {{std::string("ABCsuffix"), std::string(".*suffix$")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+TEST(FunctionLikeTest, regexp_optimization_substring) {
+ std::string func_name = "regexp";
+
+ // Test regex patterns that should be optimized to substring search
+ DataSet data_set = {
+ {{std::string("prefix_middle_suffix"), std::string(".*middle.*")},
uint8_t(1)},
+ {{std::string("no_match_here"), std::string(".*middle.*")},
uint8_t(0)},
+ {{std::string("middle"), std::string(".*middle.*")}, uint8_t(1)},
+ {{std::string("middlepart"), std::string(".*middle.*")},
uint8_t(1)},
+ {{std::string("partmiddle"), std::string(".*middle.*")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+TEST(FunctionLikeTest, regexp_special_characters) {
+ std::string func_name = "regexp";
+
+ // Test regex with special characters that need escaping
+ DataSet data_set = {{{std::string("test.txt"), std::string("test\\.txt")},
uint8_t(1)},
+ {{std::string("testXtxt"), std::string("test\\.txt")},
uint8_t(0)},
+ {{std::string("test[abc]"),
std::string("test\\[abc\\]")}, uint8_t(1)},
+ {{std::string("testabc"),
std::string("test\\[abc\\]")}, uint8_t(0)},
+ {{std::string("price$100"),
std::string("price\\$100")}, uint8_t(1)},
+ {{std::string("price100"),
std::string("price\\$100")}, uint8_t(0)},
+ {{std::string("question?"),
std::string("question\\?")}, uint8_t(1)},
+ {{std::string("questionX"),
std::string("question\\?")}, uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+// Test custom escape characters (LIKE with ESCAPE clause)
+TEST(FunctionLikeTest, like_with_custom_escape) {
+ std::string func_name = "like";
+
+ // Start with the simplest test case from regression test
+ // Test case: "a" like "aa" ESCAPE "a" -> true
+ // Pattern "aa": a+a (escape+escape) = literal a
+ DataSet data_set = {{{std::string("a"), std::string("aa"),
std::string("a")}, uint8_t(1)}};
+
+ // Ensure all parameters are correctly typed, with escape character as
constant
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR},
+ Consted {PrimitiveType::TYPE_VARCHAR}};
+
+ static_cast<void>(check_function<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test error handling and invalid patterns
+TEST(FunctionLikeTest, error_handling) {
+ std::string func_name = "regexp";
+
+ // Invalid regex patterns should handle gracefully
+ DataSet data_set = {// Valid pattern for comparison
+ {{std::string("test"), std::string("t.*t")},
uint8_t(1)},
+ {{std::string("test"), std::string("x.*x")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+// Test performance-critical substring optimization
+TEST(FunctionLikeTest, substring_optimization_performance) {
+ std::string func_name = "like";
+
+ // Test cases that should trigger execute_substring optimization
+ DataSet data_set = {// Multiple identical substrings in long text
+ {{std::string("aaabbbaaabbbaaabbb"),
std::string("%bbb%")}, uint8_t(1)},
+ {{std::string("aaacccaaacccaaaccc"),
std::string("%bbb%")}, uint8_t(0)},
+
+ // Overlapping patterns
+ {{std::string("abababab"), std::string("%aba%")},
uint8_t(1)},
+ {{std::string("abcabcabc"), std::string("%aba%")},
uint8_t(0)},
+
+ // Empty substring (should match everything)
+ {{std::string("any_text"), std::string("%%")},
uint8_t(1)},
+ {{std::string(""), std::string("%%")}, uint8_t(1)},
+
+ // Single character substrings
+ {{std::string("abc"), std::string("%a%")}, uint8_t(1)},
+ {{std::string("abc"), std::string("%x%")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test boundary conditions for pattern matching
+TEST(FunctionLikeTest, boundary_conditions) {
+ std::string func_name = "like";
+
+ DataSet data_set = {// Patterns at string boundaries
+ {{std::string("abcdef"), std::string("a%f")},
uint8_t(1)},
+ {{std::string("abcdef"), std::string("a%g")},
uint8_t(0)},
+ {{std::string("a"), std::string("a%")}, uint8_t(1)},
+ {{std::string("a"), std::string("b%")}, uint8_t(0)},
+ {{std::string("z"), std::string("%z")}, uint8_t(1)},
+ {{std::string("z"), std::string("%y")}, uint8_t(0)},
+
+ // Underscore at boundaries
+ {{std::string("abc"), std::string("_bc")}, uint8_t(1)},
+ {{std::string("abc"), std::string("ab_")}, uint8_t(1)},
+ {{std::string("ab"), std::string("_bc")}, uint8_t(0)},
+ {{std::string("ab"), std::string("ab_")}, uint8_t(0)},
+
+ // Mixed wildcards
+ {{std::string("abcdef"), std::string("_bc%")},
uint8_t(1)},
+ {{std::string("abcdef"), std::string("%def_")},
+ uint8_t(0)}, // underscore requires one more char
+ {{std::string("abcdefg"), std::string("%def_")},
uint8_t(1)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test case sensitivity and character encoding
+TEST(FunctionLikeTest, case_sensitivity_and_encoding) {
+ std::string func_name = "like";
+
+ DataSet data_set = {// Basic case sensitivity
+ {{std::string("Test"), std::string("test")},
uint8_t(0)},
+ {{std::string("TEST"), std::string("test")},
uint8_t(0)},
+ {{std::string("test"), std::string("TEST")},
uint8_t(0)},
+ {{std::string("test"), std::string("test")},
uint8_t(1)},
+
+ // Case with wildcards
+ {{std::string("TestCase"), std::string("test%")},
uint8_t(0)},
+ {{std::string("TestCase"), std::string("Test%")},
uint8_t(1)},
+ {{std::string("TestCase"), std::string("%case")},
uint8_t(0)},
+ {{std::string("TestCase"), std::string("%Case")},
uint8_t(1)},
+
+ // Unicode handling
+ {{std::string("测试"), std::string("测%")}, uint8_t(1)},
+ {{std::string("测试"), std::string("%试")}, uint8_t(1)},
+ {{std::string("测试数据"), std::string("%试%")},
uint8_t(1)},
+ {{std::string("测试数据"), std::string("%不存在%")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test vector search state transitions
+TEST(FunctionLikeTest, vector_search_state_patterns) {
+ std::string func_name = "like";
+
+ // Test different pattern types in the same vector
+ DataSet data_set = {// Mix of optimization types
+ {{std::string("allpass"), std::string("%")},
uint8_t(1)},
+ {{std::string("exact_match"),
std::string("exact_match")}, uint8_t(1)},
+ {{std::string("prefix_test"), std::string("prefix%")},
uint8_t(1)},
+ {{std::string("test_suffix"), std::string("%suffix")},
uint8_t(1)},
+ {{std::string("middle_test"),
std::string("%middle%")}, uint8_t(1)},
+ {{std::string("complex_test"), std::string("c_m%x")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test hyperscan vs RE2 fallback patterns
+TEST(FunctionLikeTest, regex_engine_patterns) {
+ std::string func_name = "regexp";
+
+ // Patterns that might test different regex engines
+ DataSet data_set = {
+ // Simple patterns (could use optimized path)
+ {{std::string("simple"), std::string("simple")}, uint8_t(1)},
+ {{std::string("prefix_test"), std::string("prefix.*")},
uint8_t(1)},
+ {{std::string("test_suffix"), std::string(".*suffix")},
uint8_t(1)},
+
+ // Complex patterns (likely to use full regex)
+ {{std::string("complex123test"),
std::string("[a-z]+[0-9]+[a-z]+")}, uint8_t(1)},
+ {{std::string("complex123"), std::string("[a-z]+[0-9]+[a-z]+")},
uint8_t(0)},
+ {{std::string("123test"), std::string("[a-z]+[0-9]+[a-z]+")},
uint8_t(0)},
+
+ // Unicode patterns
+ {{std::string("测试123"), std::string("测试[0-9]+")}, uint8_t(1)},
+ {{std::string("测试abc"), std::string("测试[0-9]+")}, uint8_t(0)},
+
+ // Lookahead/lookbehind patterns (if supported)
+ {{std::string("password123"), std::string("password.*[0-9]")},
uint8_t(1)},
+ {{std::string("password"), std::string("password.*[0-9]")},
uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR, Consted
{PrimitiveType::TYPE_VARCHAR}};
+ for (const auto& line : data_set) {
+ DataSet const_pattern_dataset = {line};
+ static_cast<void>(
+ check_function<DataTypeUInt8, true>(func_name, input_types,
const_pattern_dataset));
+ }
+}
+
+// Test memory and performance edge cases
+TEST(FunctionLikeTest, memory_and_performance) {
+ std::string func_name = "like";
+
+ DataSet data_set = {
+ // Large strings
+ {{std::string(10000, 'x'), std::string("%x%")}, uint8_t(1)},
+ {{std::string(10000, 'x'), std::string("%y%")}, uint8_t(0)},
+
+ // Many wildcards
+ {{std::string("abcdefghij"), std::string("a%b%c%d%e%f%g%h%i%j")},
uint8_t(1)},
+ {{std::string("abcdefghij"), std::string("a%b%c%d%e%f%g%h%i%k")},
uint8_t(0)},
+
+ // Alternating pattern
+ {{std::string("ababababab"), std::string("a_a_a_a_a_")},
uint8_t(1)},
+ {{std::string("ababababac"), std::string("a_a_a_a_a_")},
uint8_t(1)},
+
+ // Empty vs non-empty patterns
+ {{std::string(""), std::string("")}, uint8_t(1)},
+ {{std::string(""), std::string("_")}, uint8_t(0)},
+ {{std::string("a"), std::string("")}, uint8_t(0)}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
+// Test null handling in various scenarios
+TEST(FunctionLikeTest, comprehensive_null_handling) {
+ std::string func_name = "like";
+
+ DataSet data_set = {// Basic null cases
+ {{Null(), std::string("pattern")}, Null()},
+ {{std::string("text"), Null()}, Null()},
+ {{Null(), Null()}, Null()},
+
+ // Null with different pattern types
+ {{Null(), std::string("%")}, Null()},
+ {{Null(), std::string("exact")}, Null()},
+ {{Null(), std::string("prefix%")}, Null()},
+ {{Null(), std::string("%suffix")}, Null()},
+ {{Null(), std::string("%middle%")}, Null()},
+ {{Null(), std::string("a_b%")}, Null()},
+
+ // Valid strings with null patterns
+ {{std::string(""), Null()}, Null()},
+ {{std::string("test"), Null()}, Null()},
+ {{std::string("very_long_string_for_testing"),
Null()}, Null()}};
+
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR,
PrimitiveType::TYPE_VARCHAR};
+ static_cast<void>(
+ check_function_all_arg_comb<DataTypeUInt8, true>(func_name,
input_types, data_set));
+}
+
} // namespace doris::vectorized
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
