| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| #include "exec/es/es_query_builder.h" |
| |
| #include <gtest/gtest.h> |
| |
| #include <string> |
| #include <vector> |
| |
| #include "common/logging.h" |
| #include "exec/es/es_predicate.h" |
| #include "rapidjson/document.h" |
| #include "rapidjson/rapidjson.h" |
| #include "rapidjson/stringbuffer.h" |
| #include "rapidjson/writer.h" |
| #include "runtime/string_value.h" |
| #include "util/debug/leakcheck_disabler.h" |
| |
| namespace doris { |
| |
| class BooleanQueryBuilderTest : public testing::Test { |
| public: |
| BooleanQueryBuilderTest() {} |
| virtual ~BooleanQueryBuilderTest() {} |
| }; |
| |
| TEST_F(BooleanQueryBuilderTest, term_query) { |
| // content = "wyf" |
| char str[] = "wyf"; |
| StringValue value(str, 3); |
| ExtLiteral term_literal(TYPE_VARCHAR, &value); |
| TypeDescriptor type_desc = TypeDescriptor::create_varchar_type(3); |
| std::string name = "content"; |
| ExtBinaryPredicate term_predicate(TExprNodeType::BINARY_PRED, name, type_desc, TExprOpcode::EQ, |
| term_literal); |
| TermQueryBuilder term_query(term_predicate); |
| rapidjson::Document document; |
| rapidjson::Value term_value(rapidjson::kObjectType); |
| term_value.SetObject(); |
| term_query.to_json(&document, &term_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| term_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| //LOG(INFO) << "term query" << actual_json; |
| ASSERT_STREQ("{\"term\":{\"content\":\"wyf\"}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, range_query) { |
| // k >= a |
| char str[] = "a"; |
| StringValue value(str, 1); |
| ExtLiteral term_literal(TYPE_VARCHAR, &value); |
| TypeDescriptor type_desc = TypeDescriptor::create_varchar_type(1); |
| std::string name = "k"; |
| ExtBinaryPredicate range_predicate(TExprNodeType::BINARY_PRED, name, type_desc, TExprOpcode::GE, |
| term_literal); |
| RangeQueryBuilder range_query(range_predicate); |
| rapidjson::Document document; |
| rapidjson::Value range_value(rapidjson::kObjectType); |
| range_value.SetObject(); |
| range_query.to_json(&document, &range_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| range_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| //LOG(INFO) << "range query" << actual_json; |
| ASSERT_STREQ("{\"range\":{\"k\":{\"gte\":\"a\"}}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, es_query) { |
| // esquery('random', "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}") |
| char str[] = "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}"; |
| int length = (int)strlen(str); |
| TypeDescriptor type_desc = TypeDescriptor::create_varchar_type(length); |
| std::string name = "random"; |
| ExtColumnDesc col_des(name, type_desc); |
| std::vector<ExtColumnDesc> cols = {col_des}; |
| StringValue value(str, length); |
| ExtLiteral term_literal(TYPE_VARCHAR, &value); |
| std::vector<ExtLiteral> values = {term_literal}; |
| std::string function_name = "esquery"; |
| ExtFunction function_predicate(TExprNodeType::FUNCTION_CALL, function_name, cols, values); |
| ESQueryBuilder es_query(function_predicate); |
| rapidjson::Document document; |
| rapidjson::Value es_query_value(rapidjson::kObjectType); |
| es_query_value.SetObject(); |
| es_query.to_json(&document, &es_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| es_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| //LOG(INFO) << "es query" << actual_json; |
| ASSERT_STREQ("{\"bool\":{\"must_not\":{\"exists\":{\"field\":\"f1\"}}}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, like_query) { |
| // content like 'a%e%g_' |
| char str[] = "a%e%g_"; |
| int length = (int)strlen(str); |
| LOG(INFO) << "length " << length; |
| TypeDescriptor type_desc = TypeDescriptor::create_varchar_type(length); |
| StringValue value(str, length); |
| ExtLiteral like_literal(TYPE_VARCHAR, &value); |
| std::string name = "content"; |
| ExtLikePredicate like_predicate(TExprNodeType::LIKE_PRED, name, type_desc, like_literal); |
| WildCardQueryBuilder like_query(like_predicate); |
| rapidjson::Document document; |
| rapidjson::Value like_query_value(rapidjson::kObjectType); |
| like_query_value.SetObject(); |
| like_query.to_json(&document, &like_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| like_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| // LOG(INFO) << "wildcard query" << actual_json; |
| ASSERT_STREQ("{\"wildcard\":{\"content\":\"a*e*g?\"}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, terms_in_query) { |
| // dv in ["2.0", "4.0", "8.0"] |
| std::string terms_in_field = "dv"; |
| int terms_in_field_length = terms_in_field.length(); |
| TypeDescriptor terms_in_col_type_desc = |
| TypeDescriptor::create_varchar_type(terms_in_field_length); |
| |
| char value_1[] = "2.0"; |
| int value_1_length = (int)strlen(value_1); |
| StringValue string_value_1(value_1, value_1_length); |
| ExtLiteral term_literal_1(TYPE_VARCHAR, &string_value_1); |
| |
| char value_2[] = "4.0"; |
| int value_2_length = (int)strlen(value_2); |
| StringValue string_value_2(value_2, value_2_length); |
| ExtLiteral term_literal_2(TYPE_VARCHAR, &string_value_2); |
| |
| char value_3[] = "8.0"; |
| int value_3_length = (int)strlen(value_3); |
| StringValue string_value_3(value_3, value_3_length); |
| ExtLiteral term_literal_3(TYPE_VARCHAR, &string_value_3); |
| |
| std::vector<ExtLiteral> terms_values = {term_literal_1, term_literal_2, term_literal_3}; |
| ExtInPredicate in_predicate(TExprNodeType::IN_PRED, false, terms_in_field, |
| terms_in_col_type_desc, terms_values); |
| TermsInSetQueryBuilder terms_query(in_predicate); |
| rapidjson::Document document; |
| rapidjson::Value in_query_value(rapidjson::kObjectType); |
| in_query_value.SetObject(); |
| terms_query.to_json(&document, &in_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| in_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| //LOG(INFO) << "terms in sets query" << actual_json; |
| ASSERT_STREQ("{\"terms\":{\"dv\":[\"2.0\",\"4.0\",\"8.0\"]}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, match_all_query) { |
| // match all docs |
| MatchAllQueryBuilder match_all_query; |
| rapidjson::Document document; |
| rapidjson::Value match_all_query_value(rapidjson::kObjectType); |
| match_all_query_value.SetObject(); |
| match_all_query.to_json(&document, &match_all_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| match_all_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| //LOG(INFO) << "match all query" << actual_json; |
| ASSERT_STREQ("{\"match_all\":{}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, exists_query) { |
| // k1 is not null |
| // {"exists":{"field":"k1"}} |
| std::string exists_field = "k1"; |
| int exists_field_length = exists_field.length(); |
| TypeDescriptor exists_col_type_desc = TypeDescriptor::create_varchar_type(exists_field_length); |
| ExtIsNullPredicate isNullPredicate(TExprNodeType::IS_NULL_PRED, "k1", exists_col_type_desc, |
| true); |
| ExistsQueryBuilder exists_query(isNullPredicate); |
| rapidjson::Document document; |
| rapidjson::Value exists_query_value(rapidjson::kObjectType); |
| exists_query_value.SetObject(); |
| exists_query.to_json(&document, &exists_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| exists_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| ASSERT_STREQ("{\"exists\":{\"field\":\"k1\"}}", actual_json.c_str()); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, bool_query) { |
| // content like 'a%e%g_' |
| char like_value[] = "a%e%g_"; |
| int like_value_length = (int)strlen(like_value); |
| TypeDescriptor like_type_desc = TypeDescriptor::create_varchar_type(like_value_length); |
| StringValue like_term_value(like_value, like_value_length); |
| ExtLiteral like_literal(TYPE_VARCHAR, &like_term_value); |
| std::string like_field_name = "content"; |
| ExtLikePredicate* like_predicate = new ExtLikePredicate( |
| TExprNodeType::LIKE_PRED, like_field_name, like_type_desc, like_literal); |
| // esquery("random", "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}") |
| char es_query_str[] = "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}"; |
| int es_query_length = (int)strlen(es_query_str); |
| StringValue value(es_query_str, es_query_length); |
| TypeDescriptor es_query_type_desc = TypeDescriptor::create_varchar_type(es_query_length); |
| std::string es_query_field_name = "random"; |
| ExtColumnDesc es_query_col_des(es_query_field_name, es_query_type_desc); |
| std::vector<ExtColumnDesc> es_query_cols = {es_query_col_des}; |
| StringValue es_query_value(es_query_str, es_query_length); |
| ExtLiteral es_query_term_literal(TYPE_VARCHAR, &es_query_value); |
| std::vector<ExtLiteral> es_query_values = {es_query_term_literal}; |
| std::string function_name = "esquery"; |
| ExtFunction* function_predicate = new ExtFunction(TExprNodeType::FUNCTION_CALL, function_name, |
| es_query_cols, es_query_values); |
| // k >= a |
| char range_value_str[] = "a"; |
| int range_value_length = (int)strlen(range_value_str); |
| StringValue range_value(range_value_str, range_value_length); |
| ExtLiteral range_literal(TYPE_VARCHAR, &range_value); |
| TypeDescriptor range_type_desc = TypeDescriptor::create_varchar_type(range_value_length); |
| std::string range_field_name = "k"; |
| ExtBinaryPredicate* range_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, range_field_name, range_type_desc, |
| TExprOpcode::GE, range_literal); |
| // content = "wyf" |
| char term_str[] = "wyf"; |
| int term_value_length = (int)strlen(term_str); |
| StringValue term_value(term_str, term_value_length); |
| ExtLiteral term_literal(TYPE_VARCHAR, &term_value); |
| TypeDescriptor term_type_desc = TypeDescriptor::create_varchar_type(term_value_length); |
| std::string term_field_name = "content"; |
| ExtBinaryPredicate* term_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, term_field_name, term_type_desc, |
| TExprOpcode::EQ, term_literal); |
| |
| // content like 'a%e%g_' or k >= a or content = "wyf" |
| std::vector<ExtPredicate*> or_predicates = {like_predicate, function_predicate, range_predicate, |
| term_predicate}; |
| BooleanQueryBuilder bool_query(or_predicates); |
| rapidjson::Document document; |
| rapidjson::Value bool_query_value(rapidjson::kObjectType); |
| bool_query_value.SetObject(); |
| bool_query.to_json(&document, &bool_query_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| bool_query_value.Accept(writer); |
| std::string actual_json = buffer.GetString(); |
| std::string expected_json = |
| "{\"bool\":{\"should\":[{\"wildcard\":{\"content\":\"a*e*g?\"}},{\"bool\":{\"must_" |
| "not\":{\"exists\":{\"field\":\"f1\"}}}},{\"range\":{\"k\":{\"gte\":\"a\"}}},{\"term\":" |
| "{\"content\":\"wyf\"}}]}}"; |
| //LOG(INFO) << "bool query" << actual_json; |
| ASSERT_STREQ(expected_json.c_str(), actual_json.c_str()); |
| |
| delete like_predicate; |
| delete function_predicate; |
| delete range_predicate; |
| delete term_predicate; |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, compound_bool_query) { |
| // content like "a%e%g_" or esquery(random, '{"bool": {"must_not": {"exists": {"field": "f1"}}}}') |
| char like_value[] = "a%e%g_"; |
| int like_value_length = (int)strlen(like_value); |
| TypeDescriptor like_type_desc = TypeDescriptor::create_varchar_type(like_value_length); |
| StringValue like_term_value(like_value, like_value_length); |
| ExtLiteral like_literal(TYPE_VARCHAR, &like_term_value); |
| std::string like_field_name = "content"; |
| ExtLikePredicate* like_predicate = new ExtLikePredicate( |
| TExprNodeType::LIKE_PRED, like_field_name, like_type_desc, like_literal); |
| |
| char es_query_str[] = "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}"; |
| int es_query_length = (int)strlen(es_query_str); |
| StringValue value(es_query_str, es_query_length); |
| TypeDescriptor es_query_type_desc = TypeDescriptor::create_varchar_type(es_query_length); |
| std::string es_query_field_name = "random"; |
| ExtColumnDesc es_query_col_des(es_query_field_name, es_query_type_desc); |
| std::vector<ExtColumnDesc> es_query_cols = {es_query_col_des}; |
| StringValue es_query_value(es_query_str, es_query_length); |
| ExtLiteral es_query_term_literal(TYPE_VARCHAR, &es_query_value); |
| std::vector<ExtLiteral> es_query_values = {es_query_term_literal}; |
| std::string function_name = "esquery"; |
| ExtFunction* function_predicate = new ExtFunction(TExprNodeType::FUNCTION_CALL, function_name, |
| es_query_cols, es_query_values); |
| |
| std::vector<ExtPredicate*> bool_predicates_1 = {like_predicate, function_predicate}; |
| EsPredicate* bool_predicate_1 = new EsPredicate(bool_predicates_1); |
| |
| // k >= "a" |
| char range_value_str[] = "a"; |
| int range_value_length = (int)strlen(range_value_str); |
| StringValue range_value(range_value_str, range_value_length); |
| ExtLiteral range_literal(TYPE_VARCHAR, &range_value); |
| TypeDescriptor range_type_desc = TypeDescriptor::create_varchar_type(range_value_length); |
| std::string range_field_name = "k"; |
| ExtBinaryPredicate* range_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, range_field_name, range_type_desc, |
| TExprOpcode::GE, range_literal); |
| |
| std::vector<ExtPredicate*> bool_predicates_2 = {range_predicate}; |
| EsPredicate* bool_predicate_2 = new EsPredicate(bool_predicates_2); |
| |
| // content != "wyf" |
| char term_str[] = "wyf"; |
| int term_value_length = (int)strlen(term_str); |
| StringValue term_value(term_str, term_value_length); |
| ExtLiteral term_literal(TYPE_VARCHAR, &term_value); |
| TypeDescriptor term_type_desc = TypeDescriptor::create_varchar_type(term_value_length); |
| std::string term_field_name = "content"; |
| ExtBinaryPredicate* term_ne_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, term_field_name, term_type_desc, |
| TExprOpcode::NE, term_literal); |
| std::vector<ExtPredicate*> bool_predicates_3 = {term_ne_predicate}; |
| EsPredicate* bool_predicate_3 = new EsPredicate(bool_predicates_3); |
| |
| // fv not in [8.0, 16.0] |
| std::string terms_in_field = "fv"; |
| int terms_in_field_length = terms_in_field.length(); |
| TypeDescriptor terms_in_col_type_desc = |
| TypeDescriptor::create_varchar_type(terms_in_field_length); |
| |
| char value_1[] = "8.0"; |
| int value_1_length = (int)strlen(value_1); |
| StringValue string_value_1(value_1, value_1_length); |
| ExtLiteral term_literal_1(TYPE_VARCHAR, &string_value_1); |
| |
| char value_2[] = "16.0"; |
| int value_2_length = (int)strlen(value_2); |
| StringValue string_value_2(value_2, value_2_length); |
| ExtLiteral term_literal_2(TYPE_VARCHAR, &string_value_2); |
| |
| std::vector<ExtLiteral> terms_values = {term_literal_1, term_literal_2}; |
| ExtInPredicate* in_predicate = new ExtInPredicate(TExprNodeType::IN_PRED, true, terms_in_field, |
| terms_in_col_type_desc, terms_values); |
| std::vector<ExtPredicate*> bool_predicates_4 = {in_predicate}; |
| EsPredicate* bool_predicate_4 = new EsPredicate(bool_predicates_4); |
| |
| // (content like "a%e%g_" or esquery(random, '{"bool": {"must_not": {"exists": {"field": "f1"}}}}')) and content != "wyf" and fv not in [8.0, 16.0] |
| std::vector<EsPredicate*> and_bool_predicates = {bool_predicate_1, bool_predicate_2, |
| bool_predicate_3, bool_predicate_4}; |
| |
| rapidjson::Document document; |
| rapidjson::Value compound_bool_value(rapidjson::kObjectType); |
| compound_bool_value.SetObject(); |
| BooleanQueryBuilder::to_query(and_bool_predicates, &document, &compound_bool_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| compound_bool_value.Accept(writer); |
| std::string actual_bool_json = buffer.GetString(); |
| std::string expected_json = |
| "{\"bool\":{\"filter\":[{\"bool\":{\"should\":[{\"wildcard\":{\"content\":\"a*e*g?\"}}," |
| "{\"bool\":{\"must_not\":{\"exists\":{\"field\":\"f1\"}}}}]}},{\"bool\":{\"should\":[{" |
| "\"range\":{\"k\":{\"gte\":\"a\"}}}]}},{\"bool\":{\"should\":[{\"bool\":{\"must_not\":[" |
| "{\"term\":{\"content\":\"wyf\"}}]}}]}},{\"bool\":{\"should\":[{\"bool\":{\"must_not\":" |
| "[{\"terms\":{\"fv\":[\"8.0\",\"16.0\"]}}]}}]}}]}}"; |
| //LOG(INFO) << "compound bool query" << actual_bool_json; |
| ASSERT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); |
| delete bool_predicate_1; |
| delete bool_predicate_2; |
| delete bool_predicate_3; |
| delete bool_predicate_4; |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, validate_esquery) { |
| std::string function_name = "esquery"; |
| char field[] = "random"; |
| int field_length = (int)strlen(field); |
| TypeDescriptor es_query_type_desc = TypeDescriptor::create_varchar_type(field_length); |
| ExtColumnDesc es_query_col_des(field, es_query_type_desc); |
| std::vector<ExtColumnDesc> es_query_cols = {es_query_col_des}; |
| char es_query_str[] = "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}"; |
| int es_query_length = (int)strlen(es_query_str); |
| StringValue es_query_value(es_query_str, es_query_length); |
| ExtLiteral es_query_term_literal(TYPE_VARCHAR, &es_query_value); |
| std::vector<ExtLiteral> es_query_values = {es_query_term_literal}; |
| ExtFunction legal_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, |
| es_query_values); |
| auto st = BooleanQueryBuilder::check_es_query(legal_es_query); |
| ASSERT_TRUE(st.ok()); |
| char empty_query[] = "{}"; |
| int empty_query_length = (int)strlen(empty_query); |
| StringValue empty_query_value(empty_query, empty_query_length); |
| ExtLiteral empty_query_term_literal(TYPE_VARCHAR, &empty_query_value); |
| std::vector<ExtLiteral> empty_query_values = {empty_query_term_literal}; |
| ExtFunction empty_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, |
| empty_query_values); |
| st = BooleanQueryBuilder::check_es_query(empty_es_query); |
| ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); |
| //LOG(INFO) <<"error msg:" << st1.get_error_msg(); |
| char malformed_query[] = "{\"bool\": {\"must_not\": {\"exists\": {"; |
| int malformed_query_length = (int)strlen(malformed_query); |
| StringValue malformed_query_value(malformed_query, malformed_query_length); |
| ExtLiteral malformed_query_term_literal(TYPE_VARCHAR, &malformed_query_value); |
| std::vector<ExtLiteral> malformed_query_values = {malformed_query_term_literal}; |
| ExtFunction malformed_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, |
| malformed_query_values); |
| st = BooleanQueryBuilder::check_es_query(malformed_es_query); |
| ASSERT_STREQ(st.get_error_msg().c_str(), "malformed esquery json"); |
| char illegal_query[] = "{\"term\": {\"k1\" : \"2\"},\"match\": {\"k1\": \"3\"}}"; |
| int illegal_query_length = (int)strlen(illegal_query); |
| StringValue illegal_query_value(illegal_query, illegal_query_length); |
| ExtLiteral illegal_query_term_literal(TYPE_VARCHAR, &illegal_query_value); |
| std::vector<ExtLiteral> illegal_query_values = {illegal_query_term_literal}; |
| ExtFunction illegal_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, |
| illegal_query_values); |
| st = BooleanQueryBuilder::check_es_query(illegal_es_query); |
| ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); |
| char illegal_key_query[] = "[\"22\"]"; |
| int illegal_key_query_length = (int)strlen(illegal_key_query); |
| StringValue illegal_key_query_value(illegal_key_query, illegal_key_query_length); |
| ExtLiteral illegal_key_query_term_literal(TYPE_VARCHAR, &illegal_key_query_value); |
| std::vector<ExtLiteral> illegal_key_query_values = {illegal_key_query_term_literal}; |
| ExtFunction illegal_key_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, |
| illegal_key_query_values); |
| st = BooleanQueryBuilder::check_es_query(illegal_key_es_query); |
| ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must be a object"); |
| } |
| |
| TEST_F(BooleanQueryBuilderTest, validate_partial) { |
| // TODO(yingchun): LSAN will report some errors in this scope, we should improve the code and enable LSAN later. |
| debug::ScopedLeakCheckDisabler disable_lsan; |
| char like_value[] = "a%e%g_"; |
| int like_value_length = (int)strlen(like_value); |
| TypeDescriptor like_type_desc = TypeDescriptor::create_varchar_type(like_value_length); |
| StringValue like_term_value(like_value, like_value_length); |
| ExtLiteral like_literal(TYPE_VARCHAR, &like_term_value); |
| std::string like_field_name = "content"; |
| ExtLikePredicate* like_predicate = new ExtLikePredicate( |
| TExprNodeType::LIKE_PRED, like_field_name, like_type_desc, like_literal); |
| |
| // k >= "a" |
| char range_value_str[] = "a"; |
| int range_value_length = (int)strlen(range_value_str); |
| StringValue range_value(range_value_str, range_value_length); |
| ExtLiteral range_literal(TYPE_VARCHAR, &range_value); |
| TypeDescriptor range_type_desc = TypeDescriptor::create_varchar_type(range_value_length); |
| std::string range_field_name = "k"; |
| ExtBinaryPredicate* range_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, range_field_name, range_type_desc, |
| TExprOpcode::GE, range_literal); |
| |
| std::vector<ExtPredicate*> bool_predicates_1 = {like_predicate, range_predicate}; |
| EsPredicate* bool_predicate_1 = new EsPredicate(bool_predicates_1); |
| |
| // fv not in [8.0, 16.0] |
| std::string terms_in_field = "fv"; |
| int terms_in_field_length = terms_in_field.length(); |
| TypeDescriptor terms_in_col_type_desc = |
| TypeDescriptor::create_varchar_type(terms_in_field_length); |
| |
| char value_1[] = "8.0"; |
| int value_1_length = (int)strlen(value_1); |
| StringValue string_value_1(value_1, value_1_length); |
| ExtLiteral term_literal_1(TYPE_VARCHAR, &string_value_1); |
| |
| char value_2[] = "16.0"; |
| int value_2_length = (int)strlen(value_2); |
| StringValue string_value_2(value_2, value_2_length); |
| ExtLiteral term_literal_2(TYPE_VARCHAR, &string_value_2); |
| |
| std::vector<ExtLiteral> terms_values = {term_literal_1, term_literal_2}; |
| ExtInPredicate* in_predicate = new ExtInPredicate(TExprNodeType::IN_PRED, true, terms_in_field, |
| terms_in_col_type_desc, terms_values); |
| std::vector<ExtPredicate*> bool_predicates_2 = {in_predicate}; |
| EsPredicate* bool_predicate_2 = new EsPredicate(bool_predicates_2); |
| |
| // content != "wyf" |
| char term_str[] = "wyf"; |
| int term_value_length = (int)strlen(term_str); |
| StringValue term_value(term_str, term_value_length); |
| ExtLiteral term_literal(TYPE_VARCHAR, &term_value); |
| TypeDescriptor term_type_desc = TypeDescriptor::create_varchar_type(term_value_length); |
| std::string term_field_name = "content"; |
| ExtBinaryPredicate* term_ne_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, term_field_name, term_type_desc, |
| TExprOpcode::NE, term_literal); |
| |
| char es_query_str[] = "{\"bool\": {\"must_not\": {\"exists\": {\"field\": \"f1\"}}}}"; |
| int es_query_length = (int)strlen(es_query_str); |
| StringValue value(es_query_str, es_query_length); |
| TypeDescriptor es_query_type_desc = TypeDescriptor::create_varchar_type(es_query_length); |
| std::string es_query_field_name = "random"; |
| ExtColumnDesc es_query_col_des(es_query_field_name, es_query_type_desc); |
| std::vector<ExtColumnDesc> es_query_cols = {es_query_col_des}; |
| StringValue es_query_value(es_query_str, es_query_length); |
| ExtLiteral es_query_term_literal(TYPE_VARCHAR, &es_query_value); |
| std::vector<ExtLiteral> es_query_values = {es_query_term_literal}; |
| std::string function_name = "esquery"; |
| ExtFunction* function_predicate = new ExtFunction(TExprNodeType::FUNCTION_CALL, function_name, |
| es_query_cols, es_query_values); |
| std::vector<ExtPredicate*> bool_predicates_3 = {term_ne_predicate, function_predicate}; |
| EsPredicate* bool_predicate_3 = new EsPredicate(bool_predicates_3); |
| |
| std::vector<EsPredicate*> and_bool_predicates = {bool_predicate_1, bool_predicate_2, |
| bool_predicate_3}; |
| std::vector<bool> result; |
| BooleanQueryBuilder::validate(and_bool_predicates, &result); |
| std::vector<bool> expected = {true, true, true}; |
| ASSERT_EQ(result, expected); |
| char illegal_query[] = "{\"term\": {\"k1\" : \"2\"},\"match\": {\"k1\": \"3\"}}"; |
| int illegal_query_length = (int)strlen(illegal_query); |
| StringValue illegal_query_value(illegal_query, illegal_query_length); |
| ExtLiteral illegal_query_term_literal(TYPE_VARCHAR, &illegal_query_value); |
| std::vector<ExtLiteral> illegal_query_values = {illegal_query_term_literal}; |
| ExtFunction* illegal_function_preficate = new ExtFunction( |
| TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, illegal_query_values); |
| std::vector<ExtPredicate*> illegal_bool_predicates_3 = {term_ne_predicate, |
| illegal_function_preficate}; |
| EsPredicate* illegal_bool_predicate_3 = new EsPredicate(illegal_bool_predicates_3); |
| std::vector<EsPredicate*> and_bool_predicates_1 = {bool_predicate_1, bool_predicate_2, |
| illegal_bool_predicate_3}; |
| std::vector<bool> result1; |
| BooleanQueryBuilder::validate(and_bool_predicates_1, &result1); |
| std::vector<bool> expected1 = {true, true, false}; |
| ASSERT_EQ(result1, expected1); |
| } |
| |
| // ( k >= "a" and (fv not in [8.0, 16.0]) or (content != "wyf") ) or content like "a%e%g_" |
| |
| TEST_F(BooleanQueryBuilderTest, validate_compound_and) { |
| // TODO(yingchun): LSAN will report some errors in this scope, we should improve the code and enable LSAN later. |
| debug::ScopedLeakCheckDisabler disable_lsan; |
| std::string terms_in_field = "fv"; // fv not in [8.0, 16.0] |
| int terms_in_field_length = terms_in_field.length(); |
| TypeDescriptor terms_in_col_type_desc = |
| TypeDescriptor::create_varchar_type(terms_in_field_length); |
| |
| char value_1[] = "8.0"; |
| int value_1_length = (int)strlen(value_1); |
| StringValue string_value_1(value_1, value_1_length); |
| ExtLiteral term_literal_1(TYPE_VARCHAR, &string_value_1); |
| |
| char value_2[] = "16.0"; |
| int value_2_length = (int)strlen(value_2); |
| StringValue string_value_2(value_2, value_2_length); |
| ExtLiteral term_literal_2(TYPE_VARCHAR, &string_value_2); |
| |
| std::vector<ExtLiteral> terms_values = {term_literal_1, term_literal_2}; |
| ExtInPredicate* in_predicate = new ExtInPredicate(TExprNodeType::IN_PRED, true, terms_in_field, |
| terms_in_col_type_desc, terms_values); |
| |
| char term_str[] = "wyf"; |
| int term_value_length = (int)strlen(term_str); |
| StringValue term_value(term_str, term_value_length); |
| ExtLiteral term_literal(TYPE_VARCHAR, &term_value); |
| TypeDescriptor term_type_desc = TypeDescriptor::create_varchar_type(term_value_length); |
| std::string term_field_name = "content"; |
| ExtBinaryPredicate* term_ne_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, term_field_name, term_type_desc, |
| TExprOpcode::NE, term_literal); |
| |
| std::vector<ExtPredicate*> inner_or_content = {term_ne_predicate, in_predicate}; |
| |
| EsPredicate* inner_or_predicate = new EsPredicate(inner_or_content); |
| |
| char range_value_str[] = "a"; // k >= "a" |
| int range_value_length = (int)strlen(range_value_str); |
| StringValue range_value(range_value_str, range_value_length); |
| ExtLiteral range_literal(TYPE_VARCHAR, &range_value); |
| TypeDescriptor range_type_desc = TypeDescriptor::create_varchar_type(range_value_length); |
| std::string range_field_name = "k"; |
| ExtBinaryPredicate* range_predicate = |
| new ExtBinaryPredicate(TExprNodeType::BINARY_PRED, range_field_name, range_type_desc, |
| TExprOpcode::GE, range_literal); |
| std::vector<ExtPredicate*> range_predicates = {range_predicate}; |
| EsPredicate* left_inner_or_predicate = new EsPredicate(range_predicates); |
| |
| std::vector<EsPredicate*> outer_left_predicates_1 = {left_inner_or_predicate, |
| inner_or_predicate}; |
| |
| ExtCompPredicates* comp_predicate = |
| new ExtCompPredicates(TExprOpcode::COMPOUND_AND, outer_left_predicates_1); |
| |
| char like_value[] = "a%e%g_"; |
| int like_value_length = (int)strlen(like_value); |
| TypeDescriptor like_type_desc = TypeDescriptor::create_varchar_type(like_value_length); |
| StringValue like_term_value(like_value, like_value_length); |
| ExtLiteral like_literal(TYPE_VARCHAR, &like_term_value); |
| std::string like_field_name = "content"; |
| ExtLikePredicate* like_predicate = new ExtLikePredicate( |
| TExprNodeType::LIKE_PRED, like_field_name, like_type_desc, like_literal); |
| |
| std::vector<ExtPredicate*> or_predicate_vector = {comp_predicate, like_predicate}; |
| EsPredicate* or_predicate = new EsPredicate(or_predicate_vector); |
| |
| std::vector<EsPredicate*> or_predicates = {or_predicate}; |
| std::vector<bool> result1; |
| BooleanQueryBuilder::validate(or_predicates, &result1); |
| std::vector<bool> expected1 = {true}; |
| ASSERT_TRUE(result1 == expected1); |
| |
| rapidjson::Document document; |
| rapidjson::Value compound_and_value(rapidjson::kObjectType); |
| compound_and_value.SetObject(); |
| BooleanQueryBuilder::to_query(or_predicates, &document, &compound_and_value); |
| rapidjson::StringBuffer buffer; |
| rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); |
| compound_and_value.Accept(writer); |
| std::string actual_bool_json = buffer.GetString(); |
| std::string expected_json = |
| "{\"bool\":{\"filter\":[{\"bool\":{\"should\":[{\"bool\":{\"filter\":[{\"bool\":{" |
| "\"should\":[{\"range\":{\"k\":{\"gte\":\"a\"}}}]}},{\"bool\":{\"should\":[{\"bool\":{" |
| "\"must_not\":[{\"term\":{\"content\":\"wyf\"}}]}},{\"bool\":{\"must_not\":[{\"terms\":" |
| "{\"fv\":[\"8.0\",\"16.0\"]}}]}}]}}]}},{\"wildcard\":{\"content\":\"a*e*g?\"}}]}}]}}"; |
| ASSERT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); |
| } |
| } // namespace doris |
| |
| int main(int argc, char* argv[]) { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
