github-actions[bot] commented on code in PR #32333:
URL: https://github.com/apache/doris/pull/32333#discussion_r1527157317
##########
be/src/vec/functions/like.cpp:
##########
@@ -60,6 +60,92 @@
static const re2::RE2 LIKE_EQUALS_RE("(((\\\\_)|([^%_]))+)");
static const re2::RE2 LIKE_ALLPASS_RE("%+");
+struct VectorAllpassSearchState : public VectorLikeSearchState {
+ VectorAllpassSearchState()
+ : VectorLikeSearchState(PatternType::ALLPASS,
FunctionLikeBase::vector_allpass_fn) {}
+
+ ~VectorAllpassSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ if (!pattern_str.empty() && RE2::FullMatch(pattern_str,
LIKE_ALLPASS_RE)) {
+ _search_strings->insert_default();
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorEqualSearchState : public VectorLikeSearchState {
+ VectorEqualSearchState()
+ : VectorLikeSearchState(PatternType::EQUAL,
FunctionLikeBase::vector_equals_fn) {}
+
+ ~VectorEqualSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (pattern_str.empty() || RE2::FullMatch(pattern_str, LIKE_EQUALS_RE,
&search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorSubStringSearchState : public VectorLikeSearchState {
+ VectorSubStringSearchState()
+ : VectorLikeSearchState(PatternType::SUBSTRING,
FunctionLikeBase::vector_substring_fn) {
+ }
+
+ ~VectorSubStringSearchState() = default;
Review Comment:
warning: annotate this function with 'override' or (rarely) 'final'
[modernize-use-override]
```suggestion
~VectorSubStringSearchState() override = default;
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -60,6 +60,92 @@
static const re2::RE2 LIKE_EQUALS_RE("(((\\\\_)|([^%_]))+)");
static const re2::RE2 LIKE_ALLPASS_RE("%+");
+struct VectorAllpassSearchState : public VectorLikeSearchState {
+ VectorAllpassSearchState()
+ : VectorLikeSearchState(PatternType::ALLPASS,
FunctionLikeBase::vector_allpass_fn) {}
+
+ ~VectorAllpassSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ if (!pattern_str.empty() && RE2::FullMatch(pattern_str,
LIKE_ALLPASS_RE)) {
+ _search_strings->insert_default();
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorEqualSearchState : public VectorLikeSearchState {
+ VectorEqualSearchState()
+ : VectorLikeSearchState(PatternType::EQUAL,
FunctionLikeBase::vector_equals_fn) {}
+
+ ~VectorEqualSearchState() = default;
Review Comment:
warning: annotate this function with 'override' or (rarely) 'final'
[modernize-use-override]
```suggestion
~VectorEqualSearchState() override = default;
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -123,6 +251,29 @@
return Status::OK();
}
+Status FunctionLikeBase::constant_ends_with_fn_scalar(LikeSearchState* state,
const StringRef& val,
+ const StringRef& pattern,
+ unsigned char* result) {
+ *result = (val.size >= state->search_string_sv.size) &&
+ (state->search_string_sv == val.substring(val.size -
state->search_string_sv.size,
+
state->search_string_sv.size));
+ return Status::OK();
+}
+
+Status FunctionLikeBase::vector_ends_with_fn(const ColumnString& vals,
Review Comment:
warning: method 'vector_ends_with_fn' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_ends_with_fn(const ColumnString& vals,
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -60,6 +60,92 @@
static const re2::RE2 LIKE_EQUALS_RE("(((\\\\_)|([^%_]))+)");
static const re2::RE2 LIKE_ALLPASS_RE("%+");
+struct VectorAllpassSearchState : public VectorLikeSearchState {
+ VectorAllpassSearchState()
+ : VectorLikeSearchState(PatternType::ALLPASS,
FunctionLikeBase::vector_allpass_fn) {}
+
+ ~VectorAllpassSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ if (!pattern_str.empty() && RE2::FullMatch(pattern_str,
LIKE_ALLPASS_RE)) {
+ _search_strings->insert_default();
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorEqualSearchState : public VectorLikeSearchState {
+ VectorEqualSearchState()
+ : VectorLikeSearchState(PatternType::EQUAL,
FunctionLikeBase::vector_equals_fn) {}
+
+ ~VectorEqualSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (pattern_str.empty() || RE2::FullMatch(pattern_str, LIKE_EQUALS_RE,
&search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorSubStringSearchState : public VectorLikeSearchState {
+ VectorSubStringSearchState()
+ : VectorLikeSearchState(PatternType::SUBSTRING,
FunctionLikeBase::vector_substring_fn) {
+ }
+
+ ~VectorSubStringSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (RE2::FullMatch(pattern_str, LIKE_SUBSTRING_RE, &search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorStartsWithSearchState : public VectorLikeSearchState {
+ VectorStartsWithSearchState()
+ : VectorLikeSearchState(PatternType::STARTS_WITH,
+ FunctionLikeBase::vector_starts_with_fn) {}
+
+ ~VectorStartsWithSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (RE2::FullMatch(pattern_str, LIKE_STARTS_WITH_RE, &search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorEndsWithSearchState : public VectorLikeSearchState {
+ VectorEndsWithSearchState()
+ : VectorLikeSearchState(PatternType::ENDS_WITH,
FunctionLikeBase::vector_ends_with_fn) {
+ }
+
+ ~VectorEndsWithSearchState() = default;
Review Comment:
warning: annotate this function with 'override' or (rarely) 'final'
[modernize-use-override]
```suggestion
~VectorEndsWithSearchState() override = default;
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -60,6 +60,92 @@ static const re2::RE2
LIKE_STARTS_WITH_RE(R"((((\\%)|(\\_)|([^%_\\]))+)(?:%+))")
static const re2::RE2 LIKE_EQUALS_RE("(((\\\\_)|([^%_]))+)");
static const re2::RE2 LIKE_ALLPASS_RE("%+");
+struct VectorAllpassSearchState : public VectorLikeSearchState {
+ VectorAllpassSearchState()
+ : VectorLikeSearchState(PatternType::ALLPASS,
FunctionLikeBase::vector_allpass_fn) {}
+
+ ~VectorAllpassSearchState() = default;
Review Comment:
warning: annotate this function with 'override' or (rarely) 'final'
[modernize-use-override]
```suggestion
~VectorAllpassSearchState() override = default;
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -60,6 +60,92 @@
static const re2::RE2 LIKE_EQUALS_RE("(((\\\\_)|([^%_]))+)");
static const re2::RE2 LIKE_ALLPASS_RE("%+");
+struct VectorAllpassSearchState : public VectorLikeSearchState {
+ VectorAllpassSearchState()
+ : VectorLikeSearchState(PatternType::ALLPASS,
FunctionLikeBase::vector_allpass_fn) {}
+
+ ~VectorAllpassSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ if (!pattern_str.empty() && RE2::FullMatch(pattern_str,
LIKE_ALLPASS_RE)) {
+ _search_strings->insert_default();
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorEqualSearchState : public VectorLikeSearchState {
+ VectorEqualSearchState()
+ : VectorLikeSearchState(PatternType::EQUAL,
FunctionLikeBase::vector_equals_fn) {}
+
+ ~VectorEqualSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (pattern_str.empty() || RE2::FullMatch(pattern_str, LIKE_EQUALS_RE,
&search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorSubStringSearchState : public VectorLikeSearchState {
+ VectorSubStringSearchState()
+ : VectorLikeSearchState(PatternType::SUBSTRING,
FunctionLikeBase::vector_substring_fn) {
+ }
+
+ ~VectorSubStringSearchState() = default;
+
+ void pattern_match(const std::string& pattern_str) override {
+ std::string search_string;
+ if (RE2::FullMatch(pattern_str, LIKE_SUBSTRING_RE, &search_string)) {
+ FunctionLike::remove_escape_character(&search_string);
+ _search_strings->insert_data(search_string.c_str(),
search_string.size());
+ } else {
+ _pattern_matched = false;
+ }
+ }
+};
+
+struct VectorStartsWithSearchState : public VectorLikeSearchState {
+ VectorStartsWithSearchState()
+ : VectorLikeSearchState(PatternType::STARTS_WITH,
+ FunctionLikeBase::vector_starts_with_fn) {}
+
+ ~VectorStartsWithSearchState() = default;
Review Comment:
warning: annotate this function with 'override' or (rarely) 'final'
[modernize-use-override]
```suggestion
~VectorStartsWithSearchState() override = default;
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -111,6 +216,29 @@
return Status::OK();
}
+Status FunctionLikeBase::constant_starts_with_fn_scalar(LikeSearchState* state,
+ const StringRef& val,
+ const StringRef&
pattern,
+ unsigned char* result)
{
+ *result = (val.size >= state->search_string_sv.size) &&
+ (state->search_string_sv == val.substring(0,
state->search_string_sv.size));
+ return Status::OK();
+}
+
+Status FunctionLikeBase::vector_starts_with_fn(const ColumnString& vals,
Review Comment:
warning: method 'vector_starts_with_fn' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_starts_with_fn(const ColumnString&
vals,
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -99,6 +185,25 @@
return Status::OK();
}
+Status FunctionLikeBase::constant_allpass_fn_scalar(LikeSearchState* state,
const StringRef& val,
+ const StringRef& pattern,
+ unsigned char* result) {
+ *result = 1;
+ return Status::OK();
+}
+
+Status FunctionLikeBase::vector_allpass_fn(const ColumnString& vals,
Review Comment:
warning: method 'vector_allpass_fn' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_allpass_fn(const ColumnString& vals,
```
##########
be/src/vec/functions/like.h:
##########
@@ -118,12 +118,39 @@ using LikeFn =
std::function<doris::Status(LikeSearchState*, const ColumnString&
using ScalarLikeFn = std::function<doris::Status(LikeSearchState*, const
StringRef&,
const StringRef&, unsigned
char*)>;
+using VectorLikeFn = std::function<doris::Status(const ColumnString&, const
ColumnString&,
+ ColumnUInt8::Container&)>;
+
struct LikeState {
LikeSearchState search_state;
LikeFn function;
ScalarLikeFn scalar_function;
};
+class FunctionLikeBase;
+class FunctionLike;
+
+enum class PatternType { ALLPASS, EQUAL, SUBSTRING, STARTS_WITH, ENDS_WITH,
REGEXP };
+
+struct VectorLikeSearchState {
+ PatternType _pattern_type;
+ MutableColumnPtr _search_strings;
+ VectorLikeFn _vector_function;
+ bool _pattern_matched;
Review Comment:
warning: use default member initializer for '_pattern_matched'
[modernize-use-default-member-init]
```suggestion
bool _pattern_matched{true};
```
be/src/vec/functions/like.h:144:
```diff
- _pattern_matched(true) {}
+ {}
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -133,51 +284,41 @@
return Status::OK();
}
+Status FunctionLikeBase::constant_equals_fn_scalar(LikeSearchState* state,
const StringRef& val,
+ const StringRef& pattern,
+ unsigned char* result) {
+ *result = (val == state->search_string_sv);
+ return Status::OK();
+}
+
+Status FunctionLikeBase::vector_equals_fn(const ColumnString& vals,
Review Comment:
warning: method 'vector_equals_fn' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_equals_fn(const ColumnString& vals,
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -189,6 +330,25 @@
return Status::OK();
}
+Status FunctionLikeBase::vector_substring_fn(const ColumnString& vals,
Review Comment:
warning: method 'vector_substring_fn' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_substring_fn(const ColumnString& vals,
```
##########
be/src/vec/functions/like.cpp:
##########
@@ -416,11 +571,78 @@
return Status::OK();
}
+VLikeSearchStateSPtr FunctionLikeBase::pattern_type_recognition(const
ColumnString& patterns) {
+ VLikeSearchStateSPtr allpass_state =
std::make_shared<VectorAllpassSearchState>();
+ VLikeSearchStateSPtr equal_state =
std::make_shared<VectorEqualSearchState>();
+ VLikeSearchStateSPtr substring_state =
std::make_shared<VectorSubStringSearchState>();
+ VLikeSearchStateSPtr starts_with_state =
std::make_shared<VectorStartsWithSearchState>();
+ VLikeSearchStateSPtr ends_with_state =
std::make_shared<VectorEndsWithSearchState>();
+ size_t size = patterns.size();
+
+ for (size_t i = 0; i < size; ++i) {
+ if (!allpass_state->_pattern_matched && !equal_state->_pattern_matched
&&
+ !substring_state->_pattern_matched &&
!starts_with_state->_pattern_matched &&
+ !ends_with_state->_pattern_matched) {
+ break;
+ }
+ std::string pattern_str = patterns.get_data_at(i).to_string();
+ if (allpass_state->_pattern_matched) {
+ allpass_state->pattern_match(pattern_str);
+ }
+ if (equal_state->_pattern_matched) {
+ equal_state->pattern_match(pattern_str);
+ }
+ if (substring_state->_pattern_matched) {
+ substring_state->pattern_match(pattern_str);
+ }
+ if (starts_with_state->_pattern_matched) {
+ starts_with_state->pattern_match(pattern_str);
+ }
+ if (ends_with_state->_pattern_matched) {
+ ends_with_state->pattern_match(pattern_str);
+ }
+ }
+
+ if (allpass_state->_pattern_matched) {
+ return allpass_state;
+ } else if (equal_state->_pattern_matched) {
+ return equal_state;
+ } else if (substring_state->_pattern_matched) {
+ return substring_state;
+ } else if (starts_with_state->_pattern_matched) {
+ return starts_with_state;
+ } else if (ends_with_state->_pattern_matched) {
+ return ends_with_state;
+ } else {
+ return nullptr;
+ }
+}
+
+Status FunctionLikeBase::vector_non_const(const ColumnString& values, const
ColumnString& patterns,
Review Comment:
warning: method 'vector_non_const' can be made static
[readability-convert-member-functions-to-static]
```suggestion
static Status FunctionLikeBase::vector_non_const(const ColumnString& values,
const ColumnString& patterns,
```
be/src/vec/functions/like.cpp:624:
```diff
- size_t input_rows_count) const {
+ size_t input_rows_count) {
```
--
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: commits-unsubscr...@doris.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
