20 #include <boost/locale/conversion.hpp>
21 #include <unordered_set>
44 if (!dynamic_cast<const Analyzer::Constant*>(rhs_no_cast)) {
48 const auto& arg_ti = arg->get_type_info();
49 auto rhs = rhs_no_cast->deep_copy()->add_cast(arg_ti);
50 return makeExpr<Analyzer::InValues>(
51 arg, std::list<std::shared_ptr<Analyzer::Expr>>{rhs});
144 const std::shared_ptr<Analyzer::InValues>& lhs,
145 const std::shared_ptr<Analyzer::InValues>& rhs)
const override {
150 if (lhs->get_arg()->get_type_info() == rhs->get_arg()->get_type_info() &&
151 (*lhs->get_arg() == *rhs->get_arg())) {
152 auto union_values = lhs->get_value_list();
153 const auto& rhs_values = rhs->get_value_list();
154 union_values.insert(union_values.end(), rhs_values.begin(), rhs_values.end());
155 return makeExpr<Analyzer::InValues>(lhs->get_own_arg(), union_values);
167 auto rewritten = simple_visitor.
visit(bin_oper);
174 auto rewritten_lhs = visit(lhs.get());
175 auto rewritten_rhs = visit(rhs.get());
176 return makeExpr<Analyzer::BinOper>(bin_oper->
get_type_info(),
180 rewritten_lhs ? rewritten_lhs : lhs,
181 rewritten_rhs ? rewritten_rhs : rhs);
190 std::vector<std::shared_ptr<Analyzer::Expr>> args_copy;
192 auto const element_expr_ptr = visit(array_expr->
getElement(i));
193 auto const& element_expr_type_info = element_expr_ptr->get_type_info();
195 if (!element_expr_type_info.is_string() ||
197 args_copy.push_back(element_expr_ptr);
199 auto transient_dict_type_info = element_expr_type_info;
203 transient_dict_type_info.set_fixed_size();
204 args_copy.push_back(element_expr_ptr->add_cast(transient_dict_type_info));
209 return makeExpr<Analyzer::ArrayExpr>(
215 template <
typename T>
233 throw std::runtime_error(
"Unable to fold");
237 template <
typename T>
249 throw std::runtime_error(
"Unable to fold");
253 template <
typename T>
255 bool t2_is_zero = (t2 == (t2 - t2));
256 bool t2_is_negative = (t2 < (t2 - t2));
261 if ((t2_is_negative && t1 < std::numeric_limits<T>::lowest() - t2) ||
262 (!t2_is_negative && t1 > std::numeric_limits<T>::max() - t2)) {
264 throw std::runtime_error(
"Plus overflow");
268 if ((t2_is_negative && t1 > std::numeric_limits<T>::max() + t2) ||
269 (!t2_is_negative && t1 < std::numeric_limits<T>::lowest() + t2)) {
271 throw std::runtime_error(
"Minus overflow");
281 if (t2_is_negative) {
282 if (t1 == std::numeric_limits<T>::lowest() ||
283 t2 == std::numeric_limits<T>::lowest()) {
286 throw std::runtime_error(
"Mul neg overflow");
292 bool ct2_is_fraction = (ct2 < (ct2 / ct2));
293 if (!ct2_is_fraction) {
294 if (ct1 > std::numeric_limits<T>::max() / ct2 ||
295 ct1 < std::numeric_limits<T>::lowest() / ct2) {
297 throw std::runtime_error(
"Mul overflow");
304 throw std::runtime_error(
"Will not fold division by zero");
310 throw std::runtime_error(
"Unable to fold");
432 const auto unvisited_operand = uoper->
get_operand();
435 if (optype ==
kCAST) {
437 casts_.insert({unvisited_operand, ti});
439 const auto operand = visit(unvisited_operand);
441 const auto& operand_ti = operand->get_type_info();
442 const auto operand_type =
444 const auto const_operand =
448 const auto operand_datum = const_operand->
get_constval();
449 Datum zero_datum = {};
450 Datum result_datum = {};
461 return makeExpr<Analyzer::Constant>(result_type,
false, result_datum);
472 if (!operand_ti.is_decimal()) {
473 return makeExpr<Analyzer::Constant>(result_type,
false, result_datum);
475 return makeExpr<Analyzer::Constant>(ti,
false, result_datum);
481 if (!ti.is_number() || !operand_ti.is_number()) {
489 if (ti.is_decimal() && operand_ti.is_fp()) {
492 auto operand_copy = const_operand->deep_copy();
493 auto cast_operand = operand_copy->add_cast(ti);
494 auto const_cast_operand =
496 if (const_cast_operand) {
497 auto const_cast_datum = const_cast_operand->
get_constval();
498 return makeExpr<Analyzer::Constant>(ti,
false, const_cast_datum);
506 return makeExpr<Analyzer::UOper>(
518 if (casts_.find(bin_oper) != casts_.end()) {
519 const auto cast_ti = casts_[bin_oper];
522 if ((cast_ti.is_integer() || cast_ti.is_fp()) && lhs_ti.is_integer() &&
523 cast_ti.get_size() > lhs_ti.get_size() &&
527 left_operand = left_operand->deep_copy()->add_cast(cast_ti);
528 right_operand = right_operand->deep_copy()->add_cast(cast_ti);
533 const auto lhs = visit(left_operand.get());
534 const auto rhs = visit(right_operand.get());
539 const auto& rhs_ti = rhs->get_type_info();
543 if (const_lhs && const_rhs && lhs_type == rhs_type) {
544 auto lhs_datum = const_lhs->get_constval();
545 auto rhs_datum = const_rhs->get_constval();
546 Datum result_datum = {};
548 if (foldOper(optype, lhs_type, lhs_datum, rhs_datum, result_datum, result_type)) {
551 return makeExpr<Analyzer::Constant>(result_type,
false, result_datum);
556 return makeExpr<Analyzer::Constant>(ti,
false, result_datum);
561 if (optype ==
kAND && lhs_type == rhs_type && lhs_type ==
kBOOLEAN) {
562 if (const_rhs && !const_rhs->get_is_null()) {
563 auto rhs_datum = const_rhs->get_constval();
564 if (rhs_datum.boolval ==
false) {
568 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
573 if (const_lhs && !const_lhs->get_is_null()) {
574 auto lhs_datum = const_lhs->get_constval();
575 if (lhs_datum.boolval ==
false) {
579 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
585 if (optype ==
kOR && lhs_type == rhs_type && lhs_type ==
kBOOLEAN) {
586 if (const_rhs && !const_rhs->get_is_null()) {
587 auto rhs_datum = const_rhs->get_constval();
588 if (rhs_datum.boolval ==
true) {
592 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
597 if (const_lhs && !const_lhs->get_is_null()) {
598 auto lhs_datum = const_lhs->get_constval();
599 if (lhs_datum.boolval ==
true) {
603 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
610 if (!lhs_ti.get_notnull()) {
611 CHECK(!rhs_ti.get_notnull());
618 return makeExpr<Analyzer::BinOper>(ti,
625 CHECK(rhs_ti.get_notnull());
627 if (optype ==
kEQ || optype ==
kLE || optype ==
kGE) {
630 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
633 if (optype ==
kNE || optype ==
kLT || optype ==
kGT) {
636 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
641 return makeExpr<Analyzer::Constant>(lhs_type,
false, d);
645 if (optype ==
kDIVIDE && const_rhs && rhs_ti.is_fp()) {
646 auto rhs_datum = const_rhs->get_constval();
647 std::shared_ptr<Analyzer::Expr> recip_rhs =
nullptr;
648 if (rhs_ti.get_type() ==
kFLOAT) {
649 if (rhs_datum.floatval == 1.0) {
652 auto f = std::fabs(rhs_datum.floatval);
653 if (
f > 1.0 || (
f != 0.0 && 1.0 <
f * std::numeric_limits<float>::max())) {
654 rhs_datum.floatval = 1.0 / rhs_datum.floatval;
655 recip_rhs = makeExpr<Analyzer::Constant>(rhs_type,
false, rhs_datum);
657 }
else if (rhs_ti.get_type() ==
kDOUBLE) {
658 if (rhs_datum.doubleval == 1.0) {
661 auto d = std::fabs(rhs_datum.doubleval);
662 if (d > 1.0 || (d != 0.0 && 1.0 < d * std::numeric_limits<double>::max())) {
663 rhs_datum.doubleval = 1.0 / rhs_datum.doubleval;
664 recip_rhs = makeExpr<Analyzer::Constant>(rhs_type,
false, rhs_datum);
668 return makeExpr<Analyzer::BinOper>(ti,
677 return makeExpr<Analyzer::BinOper>(ti,
692 const auto original_args = string_oper->
getOwnArgs();
693 std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
695 const auto parent_in_string_op_chain = in_string_op_chain_;
696 const auto in_string_op_chain = non_literal_arity <= 1UL;
697 in_string_op_chain_ = in_string_op_chain;
699 size_t rewritten_arg_literal_arity = 0;
700 for (
auto original_arg : original_args) {
701 rewritten_args.emplace_back(visit(original_arg.get()));
702 if (dynamic_cast<const Analyzer::Constant*>(rewritten_args.back().get())) {
703 rewritten_arg_literal_arity++;
706 in_string_op_chain_ = parent_in_string_op_chain;
707 const auto kind = string_oper->
get_kind();
710 if (string_oper->
getArity() == rewritten_arg_literal_arity) {
714 const auto string_op_info =
716 if (return_ti.is_string()) {
717 const auto literal_result =
720 literal_result.second);
722 const auto literal_datum =
724 auto nullable_return_ti = return_ti;
725 nullable_return_ti.set_notnull(
false);
726 return makeExpr<Analyzer::Constant>(nullable_return_ti,
730 chained_string_op_exprs_.emplace_back(
731 makeExpr<Analyzer::StringOper>(kind, return_ti, rewritten_args));
732 if (parent_in_string_op_chain && in_string_op_chain) {
733 CHECK(rewritten_args[0]->get_type_info().is_string());
734 return rewritten_args[0]->deep_copy();
736 auto new_string_oper = makeExpr<Analyzer::StringOper>(
737 kind, return_ti, rewritten_args, chained_string_op_exprs_);
738 chained_string_op_exprs_.clear();
739 return new_string_oper;
744 mutable bool in_string_op_chain_{
false};
746 mutable std::unordered_map<const Analyzer::Expr*, const SQLTypeInfo>
casts_;
757 if (!with_likelihood) {
760 return with_likelihood->get_arg();
766 return ArrayElementStringLiteralEncodingVisitor().visit(expr);
782 RecursiveOrToInVisitor visitor;
783 auto rewritten_expr = visitor.visit(expr_no_likelihood);
784 const auto expr_with_likelihood =
786 if (expr_with_likelihood) {
788 return std::make_shared<Analyzer::LikelihoodExpr>(
789 rewritten_expr, expr_with_likelihood->get_likelihood());
791 return rewritten_expr;
795 const std::shared_ptr<Analyzer::Expr> expr,
796 const std::vector<InputDescriptor>& input_table_info,
798 const Executor* executor) {
799 auto collect_table_cardinality =
803 if (lhs_cv && rhs_cv) {
805 {lhs_cv->getColumnKey().db_id, lhs_cv->getColumnKey().table_id});
807 {rhs_cv->getColumnKey().db_id, rhs_cv->getColumnKey().table_id});
808 if (inner_table_metadata->fragmenter && outer_table_metadata->fragmenter) {
809 return std::make_pair<int64_t, int64_t>(
810 inner_table_metadata->fragmenter->getNumRows(),
811 outer_table_metadata->fragmenter->getNumRows());
815 return std::make_pair<int64_t, int64_t>(-1, -1);
822 std::set<int> lhs_rte_idx;
824 CHECK(!lhs_rte_idx.empty());
825 std::set<int> rhs_rte_idx;
826 rhs->collect_rte_idx(rhs_rte_idx);
827 CHECK(!rhs_rte_idx.empty());
828 auto has_invalid_num_join_cols = lhs_rte_idx.size() > 1 || rhs_rte_idx.size() > 1;
829 auto has_invalid_rte_idx = lhs_rte_idx > rhs_rte_idx;
830 return std::make_pair(has_invalid_num_join_cols || has_invalid_rte_idx,
831 has_invalid_rte_idx);
835 [&](std::string_view func_name,
836 const std::shared_ptr<Analyzer::Expr> expr,
840 const Executor* executor) -> std::shared_ptr<Analyzer::BinOper> {
843 auto l_arg = lhs->getOperand(0);
845 auto r_arg = lhs->getOperand(1);
846 const bool is_geography = l_arg->get_type_info().get_subtype() ==
kGEOGRAPHY ||
847 r_arg->get_type_info().get_subtype() ==
kGEOGRAPHY;
849 VLOG(1) <<
"Range join not yet supported for geodesic distance "
858 auto invalid_range_join_qual =
859 has_invalid_join_col_order(bin_oper_arg, range_join_arg);
860 if (invalid_range_join_qual.first) {
861 LOG(
INFO) <<
"Unable to rewrite " << func_name
862 <<
" to overlaps conjunction. Cannot build hash table over LHS type. "
863 "Check join order.\n"
864 << range_join_expr->toString();
874 bool lhs_is_point{l_arg->get_type_info().get_type() ==
kPOINT};
875 bool rhs_is_point{r_arg->get_type_info().get_type() ==
kPOINT};
876 if (!lhs_is_point || !rhs_is_point) {
878 VLOG(1) <<
"Currently, we only support range hash join for Point-to-Point "
879 "distance query: fallback to a loop join";
883 bool swap_args =
false;
884 auto const card_info =
885 collect_table_cardinality(range_join_arg, bin_oper_arg, executor);
886 if (invalid_range_join_qual.second && card_info.first > 0 && lhs_is_point) {
888 }
else if (card_info.first >= 0 && card_info.first < card_info.second) {
894 r_arg = lhs->getOperand(0);
895 l_arg = lhs->getOperand(1);
896 VLOG(1) <<
"Swap range join qual's input arguments to exploit overlaps "
897 "hash join framework";
898 invalid_range_join_qual.first =
false;
901 const bool inclusive = range_join_expr->get_optype() ==
kLE;
902 auto range_expr = makeExpr<Analyzer::RangeOper>(
903 inclusive, inclusive, r_arg->deep_copy(), rhs->deep_copy());
904 VLOG(1) <<
"Successfully converted to range hash join";
905 return makeExpr<Analyzer::BinOper>(
927 std::shared_ptr<Analyzer::BinOper> overlaps_oper{
nullptr};
928 bool needs_to_return_original_expr =
false;
929 std::string func_name{
""};
933 func_name = func_oper->getName();
936 LOG(
WARNING) <<
"Many-to-many hashjoin support is disabled, unable to rewrite "
937 << func_oper->toString() <<
" to use accelerated geo join.";
942 CHECK_GE(func_oper->getArity(), size_t(2));
951 auto lhs = func_oper->getOwnArg(0);
952 auto rewritten_lhs = deep_copy_visitor.
visit(lhs.get());
953 CHECK(rewritten_lhs);
955 auto rhs = func_oper->getOwnArg(1);
956 auto rewritten_rhs = deep_copy_visitor.
visit(rhs.get());
957 CHECK(rewritten_rhs);
958 overlaps_oper = makeExpr<Analyzer::BinOper>(
961 CHECK_EQ(func_oper->getArity(), size_t(8));
962 const auto lhs = func_oper->getOwnArg(0);
963 const auto rhs = func_oper->getOwnArg(1);
966 const auto distance_const_val =
968 if (lhs && rhs && distance_const_val) {
969 std::vector<std::shared_ptr<Analyzer::Expr>>
args{lhs, rhs};
970 auto range_oper = makeExpr<Analyzer::GeoOperator>(
975 auto distance_oper = makeExpr<Analyzer::BinOper>(
977 VLOG(1) <<
"Rewrite " << func_oper->getName() <<
" to ST_Distance_Point_Point";
985 needs_to_return_original_expr =
true;
995 CHECK_GE(func_oper->getArity(), size_t(4));
996 auto lhs = func_oper->getOwnArg(1);
997 auto rewritten_lhs = deep_copy_visitor.
visit(lhs.get());
998 CHECK(rewritten_lhs);
999 auto rhs = func_oper->getOwnArg(3);
1000 auto rewritten_rhs = deep_copy_visitor.
visit(rhs.get());
1001 CHECK(rewritten_rhs);
1003 overlaps_oper = makeExpr<Analyzer::BinOper>(
1005 needs_to_return_original_expr =
true;
1018 size_t point_arg_idx = 0;
1019 size_t poly_arg_idx = 2;
1020 if (func_oper->getOwnArg(point_arg_idx)->get_type_info().get_type() !=
kPOINT) {
1024 auto point_cv = func_oper->getOwnArg(point_arg_idx);
1025 auto poly_cv = func_oper->getOwnArg(poly_arg_idx);
1028 auto rewritten_lhs = deep_copy_visitor.
visit(point_cv.get());
1029 CHECK(rewritten_lhs);
1030 auto rewritten_rhs = deep_copy_visitor.
visit(poly_cv.get());
1031 CHECK(rewritten_rhs);
1032 VLOG(1) <<
"Rewriting the " << func_name <<
" to use overlaps join with lhs as "
1033 << rewritten_lhs->toString() <<
" and rhs as " << rewritten_rhs->toString();
1034 overlaps_oper = makeExpr<Analyzer::BinOper>(
1036 needs_to_return_original_expr =
true;
1042 auto lhs = func_oper->getOwnArg(2);
1043 auto rewritten_lhs = deep_copy_visitor.
visit(lhs.get());
1044 CHECK(rewritten_lhs);
1045 const auto& lhs_ti = rewritten_lhs->get_type_info();
1055 LOG(
INFO) <<
"Unable to rewrite " << func_name
1056 <<
" to overlaps conjunction. LHS input type is neither a geospatial "
1057 "column nor a constructed point"
1058 << func_oper->toString();
1063 auto rhs = func_oper->getOwnArg(1);
1064 auto rewritten_rhs = deep_copy_visitor.
visit(rhs.get());
1065 CHECK(rewritten_rhs);
1067 if (has_invalid_join_col_order(lhs.get(), rhs.get()).first) {
1068 LOG(
INFO) <<
"Unable to rewrite " << func_name
1069 <<
" to overlaps conjunction. Cannot build hash table over LHS type. "
1071 << func_oper->toString();
1075 VLOG(1) <<
"Rewriting " << func_name <<
" to use overlaps join with lhs as "
1076 << rewritten_lhs->toString() <<
" and rhs as " << rewritten_rhs->toString();
1078 overlaps_oper = makeExpr<Analyzer::BinOper>(
1082 needs_to_return_original_expr =
true;
1092 func_name = lhs->getName();
1095 needs_to_return_original_expr =
true;
1097 const auto expr_str = !func_name.empty() ? func_name : expr->toString();
1098 if (overlaps_oper) {
1099 VLOG(1) <<
"Successfully converted " << expr_str <<
" to overlaps join";
1100 if (needs_to_return_original_expr) {
1106 VLOG(1) <<
"Overlaps join not enabled for " << expr_str;
1121 for (
const auto& join_condition : join_quals) {
1122 for (
const auto& qual : join_condition.quals) {
1124 if (qual_bin_oper) {
1126 qual_bin_oper->get_right_operand());
1134 const auto lhs = func_oper->
getArg(2);
1135 const auto rhs = func_oper->
getArg(1);
1137 if (*lhs == *qual_pair.first && *rhs == *qual_pair.second) {
1152 const std::list<std::shared_ptr<Analyzer::Expr>>& quals,
1158 if (join_quals.empty()) {
1162 std::list<std::shared_ptr<Analyzer::Expr>> quals_to_return;
1165 for (
const auto& qual : quals) {
1166 if (!visitor.
visit(qual.get())) {
1168 quals_to_return.push_back(qual);
1172 return quals_to_return;
1180 ConstantFoldingVisitor visitor;
1181 auto rewritten_expr = visitor.visit(expr_no_likelihood);
1182 if (visitor.get_num_overflows() > 0 && rewritten_expr->get_type_info().is_integer() &&
1183 rewritten_expr->get_type_info().get_type() !=
kBIGINT) {
1184 auto rewritten_expr_const =
1186 if (!rewritten_expr_const) {
1190 auto bigint_expr_no_likelihood = expr_no_likelihood->deep_copy()->add_cast(ti);
1191 auto rewritten_expr_take2 = visitor.visit(bigint_expr_no_likelihood.get());
1192 auto rewritten_expr_take2_const =
1194 if (rewritten_expr_take2_const) {
1196 rewritten_expr = rewritten_expr_take2_const;
1201 if (expr_with_likelihood) {
1203 return std::make_shared<Analyzer::LikelihoodExpr>(
1204 rewritten_expr, expr_with_likelihood->get_likelihood());
1206 return rewritten_expr;
1211 const int max_rte_covered) {
1221 std::unordered_map<int, llvm::Value*>& scan_idx_to_hash_pos) {
1222 int ret = INT32_MIN;
1223 for (
auto& kv : scan_idx_to_hash_pos) {
1224 if (kv.first > ret) {
Defines data structures for the semantic analysis phase of query processing.
Analyzer::ExpressionPtr rewrite_array_elements(Analyzer::Expr const *expr)
static bool is_poly_mpoly_rewrite_target_func(std::string_view target_func_name)
std::shared_ptr< Analyzer::InValues > visitLikeExpr(const Analyzer::LikeExpr *) const override
std::shared_ptr< Analyzer::InValues > visitDateaddExpr(const Analyzer::DateaddExpr *) const override
Datum apply_numeric_op_to_literals(const StringOpInfo &string_op_info)
bool self_join_not_covered_by_left_deep_tree(const Analyzer::ColumnVar *key_side, const Analyzer::ColumnVar *val_side, const int max_rte_covered)
std::shared_ptr< Analyzer::WindowFunction > rewrite_avg_window(const Analyzer::Expr *expr)
bool g_strip_join_covered_quals
std::shared_ptr< Analyzer::InValues > visitKeyForString(const Analyzer::KeyForStringExpr *) const override
boost::optional< OverlapsJoinConjunction > rewrite_overlaps_conjunction(const std::shared_ptr< Analyzer::Expr > expr, const std::vector< InputDescriptor > &input_table_info, const OverlapsJoinRewriteType rewrite_type, const Executor *executor)
std::shared_ptr< Analyzer::WindowFunction > rewrite_sum_window(const Analyzer::Expr *expr)
static bool is_overlaps_supported_func(std::string_view target_func_name)
std::shared_ptr< Analyzer::InValues > visitBinOper(const Analyzer::BinOper *bin_oper) const override
const Expr * get_right_operand() const
bool is_constructed_point(const Analyzer::Expr *expr)
const TableDescriptor * get_metadata_for_table(const ::shared::TableKey &table_key, bool populate_fragmenter)
bool get_contains_agg() const
std::shared_ptr< Analyzer::Expr > ExpressionPtr
const Analyzer::Expr * extract_cast_arg(const Analyzer::Expr *expr)
std::vector< JoinCondition > JoinQualsPerNestingLevel
T visit(const Analyzer::Expr *expr) const
Analyzer::ExpressionPtr rewrite_expr(const Analyzer::Expr *expr)
#define TRANSIENT_DICT_ID
static constexpr std::string_view ST_DWITHIN_POINT_POINT_sv
std::shared_ptr< Analyzer::InValues > aggregateResult(const std::shared_ptr< Analyzer::InValues > &lhs, const std::shared_ptr< Analyzer::InValues > &rhs) const override
std::list< std::shared_ptr< Analyzer::Expr > > strip_join_covered_filter_quals(const std::list< std::shared_ptr< Analyzer::Expr >> &quals, const JoinQualsPerNestingLevel &join_quals)
std::shared_ptr< Analyzer::InValues > visitUOper(const Analyzer::UOper *uoper) const override
const int get_max_rte_scan_table(std::unordered_map< int, llvm::Value * > &scan_idx_to_hash_pos)
static constexpr std::string_view ST_OVERLAPS_sv
std::shared_ptr< Analyzer::Expr > visitBinOper(const Analyzer::BinOper *bin_oper) const override
std::shared_ptr< Analyzer::Expr > RetType
static constexpr std::string_view ST_DISTANCE_sv
std::shared_ptr< Analyzer::InValues > visitCharLength(const Analyzer::CharLengthExpr *) const override
std::shared_ptr< Analyzer::InValues > visitInIntegerSet(const Analyzer::InIntegerSet *) const override
SQLOps get_optype() const
std::shared_ptr< Analyzer::Expr > visitUOper(const Analyzer::UOper *uoper) const override
LiteralArgMap getLiteralArgs() const
Classes representing a parse tree.
bool g_enable_hashjoin_many_to_many
std::shared_ptr< Analyzer::InValues > visitRegexpExpr(const Analyzer::RegexpExpr *) const override
static bool is_many_to_many_func(std::string_view target_func_name)
static bool is_range_join_rewrite_target_func(std::string_view target_func_name)
std::shared_ptr< Analyzer::InValues > visitAggExpr(const Analyzer::AggExpr *) const override
bool visitFunctionOper(const Analyzer::FunctionOper *func_oper) const override
bool foldOper(SQLOps optype, SQLTypes type, Datum lhs, Datum rhs, Datum &result, SQLTypes &result_type) const
std::pair< std::string, bool > apply_string_op_to_literals(const StringOpInfo &string_op_info)
bool defaultResult() const override
std::shared_ptr< Analyzer::Expr > visitStringOper(const Analyzer::StringOper *string_oper) const override
static bool is_poly_point_rewrite_target_func(std::string_view target_func_name)
RetType visitArrayOper(const Analyzer::ArrayExpr *array_expr) const override
bool IsNullDatum(const Datum datum, const SQLTypeInfo &ti)
static constexpr std::string_view ST_APPROX_OVERLAPS_MULTIPOLYGON_POINT_sv
const SQLTypeInfo & get_type_info() const
std::shared_ptr< Analyzer::Expr > visitBinOper(const Analyzer::BinOper *bin_oper) const override
size_t getElementCount() const
SQLTypes decimal_to_int_type(const SQLTypeInfo &ti)
bool foldLogic(SQLOps optype, T t1, T t2) const
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
std::vector< std::pair< const Analyzer::Expr *, const Analyzer::Expr * > > join_qual_pairs
Expression class for string functions The "arg" constructor parameter must be an expression that reso...
static std::shared_ptr< Analyzer::Expr > analyzeValue(const std::string &stringval, const bool is_null)
bool isLocalAlloc() const
SqlStringOpKind get_kind() const
const Analyzer::Expr * getArg(const size_t i) const
const Expr * get_operand() const
Datum get_constval() const
std::unordered_map< const Analyzer::Expr *, const SQLTypeInfo > casts_
std::shared_ptr< Analyzer::InValues > visitDatediffExpr(const Analyzer::DatediffExpr *) const override
std::shared_ptr< Analyzer::InValues > visitLikelihood(const Analyzer::LikelihoodExpr *) const override
std::shared_ptr< Analyzer::InValues > visitInValues(const Analyzer::InValues *) const override
boost::optional< OverlapsJoinConjunction > convert_to_range_join_oper(const std::shared_ptr< Analyzer::Expr > expr, const Analyzer::BinOper *range_join_expr, const Analyzer::GeoOperator *lhs, const Analyzer::Constant *rhs)
virtual void collect_rte_idx(std::set< int > &rte_idx_set) const
T foldArithmetic(SQLOps optype, T t1, T t2) const
int32_t get_num_overflows()
const Expr * get_left_operand() const
Common Enum definitions for SQL processing.
std::shared_ptr< Analyzer::InValues > visitCaseExpr(const Analyzer::CaseExpr *) const override
JoinCoveredQualVisitor(const JoinQualsPerNestingLevel &join_quals)
const std::shared_ptr< Analyzer::Expr > get_own_right_operand() const
std::string getName() const
int32_t get_rte_idx() const
bool foldComparison(SQLOps optype, T t1, T t2) const
size_t getNonLiteralsArity() const
std::shared_ptr< Analyzer::InValues > visitDatetruncExpr(const Analyzer::DatetruncExpr *) const override
const std::shared_ptr< Analyzer::Expr > get_own_left_operand() const
std::vector< std::shared_ptr< Analyzer::Expr > > getOwnArgs() const
SQLOps get_optype() const
std::shared_ptr< Analyzer::Expr > fold_expr(const Analyzer::Expr *expr)
shared::TableKey getTableKey() const
std::shared_ptr< Analyzer::InValues > visitExtractExpr(const Analyzer::ExtractExpr *) const override
static bool is_point_poly_rewrite_target_func(std::string_view target_func_name)
const Analyzer::Expr * getElement(const size_t i) const
SQLQualifier get_qualifier() const
const Analyzer::Expr * strip_likelihood(const Analyzer::Expr *expr)
std::shared_ptr< Analyzer::InValues > visitSampleRatio(const Analyzer::SampleRatioExpr *) const override
void reset_num_overflows()
std::shared_ptr< Analyzer::InValues > visitCardinality(const Analyzer::CardinalityExpr *) const override