47 const int precision) {
59 std::shared_ptr<Analyzer::Expr> rhs;
61 const auto rex_operator =
dynamic_cast<const RexOperator*
>(rex_scalar);
63 return std::make_pair(rhs, sql_qual);
66 const auto qual_str = rex_function ? rex_function->
getName() :
"";
67 if (qual_str ==
"PG_ANY"sv || qual_str ==
"PG_ALL"sv) {
68 CHECK_EQ(
size_t(1), rex_function->size());
70 sql_qual = (qual_str ==
"PG_ANY"sv) ?
kANY :
kALL;
72 if (!rhs && rex_operator->getOperator() ==
kCAST) {
73 CHECK_EQ(
size_t(1), rex_operator->size());
76 return std::make_pair(rhs, sql_qual);
82 bool is_null_const{
false};
83 switch (ti.get_type()) {
85 const auto ival = boost::get<int64_t>(scalar_tv);
95 const auto ival = boost::get<int64_t>(scalar_tv);
100 d.tinyintval = *ival;
105 const auto ival = boost::get<int64_t>(scalar_tv);
108 is_null_const =
true;
110 d.smallintval = *ival;
115 const auto ival = boost::get<int64_t>(scalar_tv);
118 is_null_const =
true;
130 const auto ival = boost::get<int64_t>(scalar_tv);
133 is_null_const =
true;
140 const auto dval = boost::get<double>(scalar_tv);
143 is_null_const =
true;
150 const auto fval = boost::get<float>(scalar_tv);
153 is_null_const =
true;
162 auto nullable_sptr = boost::get<NullableString>(scalar_tv);
163 CHECK(nullable_sptr);
164 if (boost::get<void*>(nullable_sptr)) {
165 is_null_const =
true;
167 auto sptr = boost::get<std::string>(nullable_sptr);
168 d.stringval =
new std::string(*sptr);
173 CHECK(
false) <<
"Unhandled type: " << ti.get_type_name();
175 return {d, is_null_const};
182 const auto rex_input =
dynamic_cast<const RexInput*
>(rex);
186 const auto rex_literal =
dynamic_cast<const RexLiteral*
>(rex);
191 if (rex_window_function) {
198 const auto rex_operator =
dynamic_cast<const RexOperator*
>(rex);
202 const auto rex_case =
dynamic_cast<const RexCase*
>(rex);
206 const auto rex_subquery =
dynamic_cast<const RexSubQuery*
>(rex);
217 if ((agg_kind ==
kMIN || agg_kind ==
kMAX || agg_kind ==
kSUM || agg_kind ==
kAVG) &&
229 const std::vector<std::shared_ptr<Analyzer::Expr>>& scalar_sources) {
233 std::shared_ptr<Analyzer::Expr> arg_expr;
234 std::shared_ptr<Analyzer::Constant> arg1;
237 CHECK_LT(operand, scalar_sources.size());
239 arg_expr = scalar_sources[operand];
243 if (!arg1 || arg1->get_type_info().get_type() !=
kINT ||
244 arg1->get_constval().intval < 1 || arg1->get_constval().intval > 100) {
245 throw std::runtime_error(
246 "APPROX_COUNT_DISTINCT's second parameter should be SMALLINT literal between "
251 throw std::runtime_error(
252 "APPROX_PERCENTILE/MEDIAN is not supported in distributed mode at this "
256 if (rex->
size() == 2) {
268 arg1 = std::make_shared<Analyzer::Constant>(
kDOUBLE,
false, median);
271 const auto& arg_ti = arg_expr->get_type_info();
273 throw std::runtime_error(
"Aggregate on " + arg_ti.get_type_name() +
274 " is not supported yet.");
277 const auto agg_ti =
get_agg_type(agg_kind, arg_expr.get());
278 return makeExpr<Analyzer::AggExpr>(agg_ti, agg_kind, arg_expr,
is_distinct, arg1);
282 const RexLiteral* rex_literal) {
284 rex_literal->getType(), rex_literal->getScale(), rex_literal->getPrecision());
286 rex_literal->getTargetScale(),
287 rex_literal->getTargetPrecision());
288 switch (rex_literal->getType()) {
292 d.
bigintval = rex_literal->getVal<int64_t>();
293 return makeExpr<Analyzer::Constant>(rex_literal->getType(),
false, d);
296 const auto val = rex_literal->getVal<int64_t>();
297 const int precision = rex_literal->getPrecision();
298 const int scale = rex_literal->getScale();
299 if (target_ti.is_fp() && !scale) {
304 return lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
312 d.
boolval = rex_literal->getVal<
bool>();
313 return makeExpr<Analyzer::Constant>(
kBOOLEAN,
false, d);
317 d.
doubleval = rex_literal->getVal<
double>();
318 auto lit_expr = makeExpr<Analyzer::Constant>(
kDOUBLE,
false, d);
319 return lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
324 d.
bigintval = rex_literal->getVal<int64_t>();
325 return makeExpr<Analyzer::Constant>(rex_literal->getType(),
false, d);
331 rex_literal->getType() ==
kTIMESTAMP && rex_literal->getPrecision() > 0
332 ? rex_literal->getVal<int64_t>()
333 : rex_literal->getVal<int64_t>() / 1000;
334 return makeExpr<Analyzer::Constant>(
335 SQLTypeInfo(rex_literal->getType(), rex_literal->getPrecision(), 0,
false),
341 d.
bigintval = rex_literal->getVal<int64_t>() * 24 * 3600;
342 return makeExpr<Analyzer::Constant>(rex_literal->getType(),
false, d);
345 if (target_ti.is_array()) {
349 return makeExpr<Analyzer::ArrayExpr>(target_ti,
args,
true);
351 return makeExpr<Analyzer::Constant>(rex_literal->getTargetType(),
true,
Datum{0});
354 LOG(
FATAL) <<
"Unexpected literal type " << lit_ti.get_type_name();
361 const RexSubQuery* rex_subquery)
const {
363 throw std::runtime_error(
"EXPLAIN is not supported with sub-queries");
366 auto result = rex_subquery->getExecutionResult();
367 auto row_set =
result->getRows();
368 const size_t row_count = row_set->rowCount();
369 if (row_count >
size_t(1)) {
370 throw std::runtime_error(
"Scalar sub-query returned multiple rows");
372 if (row_count ==
size_t(0)) {
373 if (row_set->isValidationOnlyRes()) {
375 return makeExpr<Analyzer::Constant>(rex_subquery->getType(),
false, d);
377 throw std::runtime_error(
"Scalar sub-query returned no results");
380 row_set->moveToBegin();
381 auto first_row = row_set->getNextRow(
false,
false);
382 CHECK_EQ(first_row.size(), size_t(1));
383 auto scalar_tv = boost::get<ScalarTargetValue>(&first_row[0]);
384 auto ti = rex_subquery->getType();
385 if (ti.is_string()) {
386 throw std::runtime_error(
"Scalar sub-queries which return strings not supported");
389 bool is_null_const{
false};
391 return makeExpr<Analyzer::Constant>(ti, is_null_const, d);
399 <<
"Not found in input_to_nest_level_, source="
401 const int rte_idx = it_rte_idx->second;
402 const auto scan_source =
dynamic_cast<const RelScan*
>(source);
407 CHECK(in_metainfo.empty());
408 const auto table_desc = scan_source->getTableDescriptor();
412 auto col_ti = cd->columnType;
413 if (col_ti.is_string()) {
414 col_ti.set_type(
kTEXT);
416 if (cd->isVirtualCol) {
424 col_ti.set_notnull(
false);
426 return std::make_shared<Analyzer::ColumnVar>(
427 col_ti, table_desc->tableId, cd->columnId, rte_idx);
429 CHECK(!in_metainfo.empty()) <<
"for "
432 const size_t col_id = rex_input->
getIndex();
433 CHECK_LT(col_id, in_metainfo.size());
434 auto col_ti = in_metainfo[col_id].get_type_info();
439 col_ti.set_notnull(
false);
443 return std::make_shared<Analyzer::ColumnVar>(col_ti, -source->getId(), col_id, rte_idx);
453 const auto& target_ti = rex_operator->
getType();
455 const auto& operand_ti = operand_expr->get_type_info();
456 if (operand_ti.is_string() && target_ti.is_string()) {
459 if (target_ti.is_time() ||
463 return target_ti.is_date_in_days()
465 : operand_expr->add_cast(target_ti);
467 if (!operand_ti.is_string() && target_ti.is_string()) {
468 return operand_expr->add_cast(target_ti);
470 return std::make_shared<Analyzer::UOper>(target_ti,
false, sql_op, operand_expr);
473 const auto& target_ti = rex_operator->
getType();
475 const auto& operand_ti = operand_expr->get_type_info();
476 CHECK(operand_ti.is_string());
477 if (operand_ti.is_dict_encoded_string()) {
481 if (operand_expr->get_num_column_vars(
true) == 0UL) {
485 throw std::runtime_error(
486 "ENCODE_TEXT is not currently supported in distributed mode at this time.");
493 return makeExpr<Analyzer::UOper>(
494 casted_target_ti, operand_expr->get_contains_agg(),
kCAST, operand_expr);
498 return std::make_shared<Analyzer::UOper>(
kBOOLEAN, sql_op, operand_expr);
505 const auto& ti = operand_expr->get_type_info();
506 return std::make_shared<Analyzer::UOper>(ti,
false,
kUMINUS, operand_expr);
509 const auto& ti = operand_expr->get_type_info();
510 CHECK(ti.is_array());
511 return makeExpr<Analyzer::UOper>(ti.get_elem_type(),
false,
kUNNEST, operand_expr);
522 const ResultSet& val_set) {
527 throw std::runtime_error(
528 "Unable to handle 'expr IN (subquery)', subquery returned 5M+ rows.");
530 std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
532 std::vector<std::list<std::shared_ptr<Analyzer::Expr>>> expr_set(
533 fetcher_count, std::list<std::shared_ptr<Analyzer::Expr>>());
534 std::vector<std::future<void>> fetcher_threads;
535 const auto& ti = arg->get_type_info();
536 const auto entry_count = val_set.entryCount();
539 stride = (entry_count + fetcher_count - 1) / fetcher_count;
540 i < fetcher_count && start_entry < entry_count;
541 ++i, start_entry += stride) {
542 const auto end_entry = std::min(start_entry + stride, entry_count);
545 [&](std::list<std::shared_ptr<Analyzer::Expr>>& in_vals,
548 for (
auto index = start; index < end; ++index) {
549 auto row = val_set.getRowAt(index);
553 auto scalar_tv = boost::get<ScalarTargetValue>(&row[0]);
555 bool is_null_const{
false};
558 auto ti_none_encoded = ti;
560 auto none_encoded_string =
561 makeExpr<Analyzer::Constant>(ti, is_null_const, d);
562 auto dict_encoded_string = std::make_shared<Analyzer::UOper>(
563 ti,
false,
kCAST, none_encoded_string);
564 in_vals.push_back(dict_encoded_string);
566 in_vals.push_back(makeExpr<Analyzer::Constant>(ti, is_null_const, d));
570 std::ref(expr_set[i]),
574 for (
auto& child : fetcher_threads) {
578 val_set.moveToBegin();
579 for (
auto& exprs : expr_set) {
580 value_exprs.splice(value_exprs.end(), exprs);
582 return makeExpr<Analyzer::InValues>(arg, value_exprs);
595 throw std::runtime_error(
"EXPLAIN is not supported with sub-queries");
600 const auto rex_subquery =
dynamic_cast<const RexSubQuery*
>(rhs);
602 auto ti = lhs->get_type_info();
603 auto result = rex_subquery->getExecutionResult();
605 auto& row_set =
result->getRows();
606 CHECK_EQ(
size_t(1), row_set->colCount());
607 const auto& rhs_ti = row_set->getColType(0);
608 if (rhs_ti.get_type() != ti.get_type()) {
609 throw std::runtime_error(
610 "The two sides of the IN operator must have the same type; found " +
611 ti.get_type_name() +
" and " + rhs_ti.get_type_name());
613 row_set->moveToBegin();
614 if (row_set->entryCount() > 10000) {
615 std::shared_ptr<Analyzer::Expr> expr;
616 if ((ti.is_integer() || (ti.is_string() && ti.get_compression() ==
kENCODING_DICT)) &&
617 !row_set->getQueryMemDesc().didOutputColumnar()) {
622 if (expr && std::static_pointer_cast<Analyzer::InIntegerSet>(expr)
634 std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
636 auto row = row_set->getNextRow(
true,
false);
641 throw std::runtime_error(
642 "Unable to handle 'expr IN (subquery)', subquery returned 10000+ rows.");
644 auto scalar_tv = boost::get<ScalarTargetValue>(&row[0]);
646 bool is_null_const{
false};
649 auto ti_none_encoded = ti;
651 auto none_encoded_string = makeExpr<Analyzer::Constant>(ti, is_null_const, d);
652 auto dict_encoded_string =
653 std::make_shared<Analyzer::UOper>(ti,
false,
kCAST, none_encoded_string);
654 value_exprs.push_back(dict_encoded_string);
656 value_exprs.push_back(makeExpr<Analyzer::Constant>(ti, is_null_const, d));
659 return makeExpr<Analyzer::InValues>(lhs, value_exprs);
667 std::vector<int64_t>& in_vals,
668 std::atomic<size_t>& total_in_vals_count,
669 const ResultSet* values_rowset,
670 const std::pair<int64_t, int64_t> values_rowset_slice,
673 const int64_t needle_null_val) {
674 CHECK(in_vals.empty());
675 bool dicts_are_equal = source_dict == dest_dict;
676 for (
auto index = values_rowset_slice.first; index < values_rowset_slice.second;
678 const auto row = values_rowset->getOneColRow(index);
682 if (dicts_are_equal) {
683 in_vals.push_back(row.value);
685 const int string_id =
686 row.value == needle_null_val
690 in_vals.push_back(string_id);
695 throw std::runtime_error(
696 "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
702 std::atomic<size_t>& total_in_vals_count,
703 const ResultSet* values_rowset,
704 const std::pair<int64_t, int64_t> values_rowset_slice) {
705 CHECK(in_vals.empty());
706 for (
auto index = values_rowset_slice.first; index < values_rowset_slice.second;
708 const auto row = values_rowset->getOneColRow(index);
710 in_vals.push_back(row.value);
713 throw std::runtime_error(
714 "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
728 std::vector<int64_t>& in_vals,
729 std::atomic<size_t>& total_in_vals_count,
730 const ResultSet* values_rowset,
731 const std::pair<int64_t, int64_t> values_rowset_slice,
732 const std::vector<LeafHostInfo>& leaf_hosts,
735 const int32_t dest_generation,
736 const int64_t needle_null_val) {
737 CHECK(in_vals.empty());
738 std::vector<int32_t> source_ids;
739 source_ids.reserve(values_rowset->entryCount());
740 bool has_nulls =
false;
741 if (source_dict_ref == dest_dict_ref) {
742 in_vals.reserve(values_rowset_slice.second - values_rowset_slice.first +
744 for (
auto index = values_rowset_slice.first; index < values_rowset_slice.second;
746 const auto row = values_rowset->getOneColRow(index);
750 if (row.value != needle_null_val) {
751 in_vals.push_back(row.value);
754 throw std::runtime_error(
755 "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
769 for (
auto index = values_rowset_slice.first; index < values_rowset_slice.second;
771 const auto row = values_rowset->getOneColRow(index);
773 if (row.value != needle_null_val) {
774 source_ids.push_back(row.value);
780 std::vector<int32_t> dest_ids;
787 CHECK_EQ(dest_ids.size(), source_ids.size());
788 in_vals.reserve(dest_ids.size() + (has_nulls ? 1 : 0));
790 in_vals.push_back(needle_null_val);
792 for (
const int32_t dest_id : dest_ids) {
794 in_vals.push_back(dest_id);
797 throw std::runtime_error(
798 "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
813 std::shared_ptr<Analyzer::Expr> arg,
814 const ResultSet& val_set)
const {
818 std::vector<int64_t> value_exprs;
820 std::vector<std::vector<int64_t>> expr_set(fetcher_count);
821 std::vector<std::future<void>> fetcher_threads;
822 const auto& arg_type = arg->get_type_info();
823 const auto entry_count = val_set.entryCount();
824 CHECK_EQ(
size_t(1), val_set.colCount());
825 const auto& col_type = val_set.getColType(0);
827 (col_type.get_comp_param() <= 0 || arg_type.get_comp_param() <= 0)) {
831 std::atomic<size_t> total_in_vals_count{0};
834 stride = (entry_count + fetcher_count - 1) / fetcher_count;
835 i < fetcher_count && start_entry < entry_count;
836 ++i, start_entry += stride) {
837 expr_set[i].reserve(entry_count / fetcher_count);
838 const auto end_entry = std::min(start_entry + stride, entry_count);
839 if (arg_type.is_string()) {
845 const auto dd =
executor_->getStringDictionaryProxy(
846 arg_type.get_comp_param(), val_set.getRowSetMemOwner(),
true);
847 const auto sd =
executor_->getStringDictionaryProxy(
848 col_type.get_comp_param(), val_set.getRowSetMemOwner(),
true);
855 &total_in_vals_count,
861 std::vector<int64_t>& in_vals,
const size_t start,
const size_t end) {
883 std::ref(expr_set[i]),
887 CHECK(arg_type.is_integer());
890 [&val_set, &total_in_vals_count](
891 std::vector<int64_t>& in_vals,
const size_t start,
const size_t end) {
894 std::ref(expr_set[i]),
899 for (
auto& child : fetcher_threads) {
903 val_set.moveToBegin();
904 value_exprs.reserve(entry_count);
905 for (
auto& exprs : expr_set) {
906 value_exprs.insert(value_exprs.end(), exprs.begin(), exprs.end());
908 return makeExpr<Analyzer::InIntegerSet>(
909 arg, value_exprs, arg_type.get_notnull() && col_type.get_notnull());
915 if (rex_operator->
size() == 1) {
924 if (date_plus_minus) {
925 return date_plus_minus;
937 for (
size_t i = 1; i < rex_operator->
size(); ++i) {
938 std::shared_ptr<Analyzer::Expr> rhs;
940 const auto rhs_op = rex_operator->
getOperand(i);
960 const auto lhs_ti = lhs->get_type_info();
961 if (lhs_ti.is_geometry()) {
964 throw std::runtime_error(
965 "Overlaps equivalence is currently only supported for geospatial types");
970 const RexCase* rex_case)
const {
971 std::shared_ptr<Analyzer::Expr> else_expr;
972 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
974 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
977 expr_list.emplace_back(when_expr, then_expr);
992 if (!partition_count->get_type_info().is_integer()) {
993 throw std::runtime_error(
994 "PARTITION_COUNT expression of width_bucket function expects an integer type.");
996 auto check_numeric_type =
997 [](
const std::string& col_name,
const Analyzer::Expr* expr,
bool allow_null_type) {
998 if (expr->get_type_info().get_type() ==
kNULLT) {
999 if (!allow_null_type) {
1000 throw std::runtime_error(
1001 col_name +
" expression of width_bucket function expects non-null type.");
1005 if (!expr->get_type_info().is_number()) {
1006 throw std::runtime_error(
1007 col_name +
" expression of width_bucket function expects a numeric type.");
1011 check_numeric_type(
"TARGET_VALUE", target_value.get(),
true);
1012 check_numeric_type(
"LOWER_BOUND", lower_bound.get(),
false);
1013 check_numeric_type(
"UPPER_BOUND", upper_bound.get(),
false);
1015 auto cast_to_double_if_necessary = [](std::shared_ptr<Analyzer::Expr> arg) {
1016 const auto& arg_ti = arg->get_type_info();
1017 if (arg_ti.get_type() !=
kDOUBLE) {
1019 return arg->add_cast(double_ti);
1023 target_value = cast_to_double_if_necessary(target_value);
1024 lower_bound = cast_to_double_if_necessary(lower_bound);
1025 upper_bound = cast_to_double_if_necessary(upper_bound);
1026 return makeExpr<Analyzer::WidthBucketExpr>(
1032 CHECK(rex_function->
size() == 2 || rex_function->
size() == 3);
1035 if (!std::dynamic_pointer_cast<const Analyzer::Constant>(like)) {
1036 throw std::runtime_error(
"The matching pattern must be a literal.");
1038 const auto escape = (rex_function->
size() == 3)
1041 const bool is_ilike = rex_function->
getName() ==
"PG_ILIKE"sv;
1047 CHECK(rex_function->
size() == 2 || rex_function->
size() == 3);
1050 if (!std::dynamic_pointer_cast<const Analyzer::Constant>(pattern)) {
1051 throw std::runtime_error(
"The matching pattern must be a literal.");
1053 const auto escape = (rex_function->
size() == 3)
1063 return makeExpr<Analyzer::LikelihoodExpr>(arg, 0.9375);
1070 return makeExpr<Analyzer::LikelihoodExpr>(arg, 0.0625);
1076 const std::shared_ptr<Analyzer::Constant> literal_expr) {
1077 if (!literal_expr || literal_expr->get_is_null()) {
1078 throw std::runtime_error(
"The 'DatePart' argument must be a not 'null' literal.");
1091 const bool is_date_trunc = rex_function->
getName() ==
"PG_DATE_TRUNC"sv;
1092 if (is_date_trunc) {
1107 datum.tinyintval = val;
1111 datum.smallintval = val;
1119 datum.bigintval = val;
1128 datum.floatval = val;
1132 datum.doubleval = val;
1138 return makeExpr<Analyzer::Constant>(ti,
false, datum);
1150 const auto number_units_const =
1152 if (number_units_const && number_units_const->get_is_null()) {
1153 throw std::runtime_error(
"The 'Interval' argument literal must not be 'null'.");
1157 const auto& datetime_ti = datetime->get_type_info();
1158 if (datetime_ti.get_type() ==
kTIME) {
1159 throw std::runtime_error(
"DateAdd operation not supported for TIME.");
1162 const int dim = datetime_ti.get_dimension();
1163 return makeExpr<Analyzer::DateaddExpr>(
1171 return "DATETIME_PLUS"s;
1178 if (rex_operator->
size() != 2) {
1182 const auto datetime_ti = datetime->get_type_info();
1183 if (!datetime_ti.is_timestamp() && !datetime_ti.is_date()) {
1184 if (datetime_ti.get_type() ==
kTIME) {
1185 throw std::runtime_error(
"DateTime addition/subtraction not supported for TIME.");
1190 const auto rhs_ti = rhs->get_type_info();
1192 if (datetime_ti.is_high_precision_timestamp() ||
1193 rhs_ti.is_high_precision_timestamp()) {
1194 throw std::runtime_error(
1195 "High Precision timestamps are not supported for TIMESTAMPDIFF operation. "
1200 const auto& rex_operator_ti = rex_operator->
getType();
1201 const auto datediff_field =
1204 makeExpr<Analyzer::DatediffExpr>(bigint_ti, datediff_field, rhs, datetime);
1207 return makeExpr<Analyzer::BinOper>(bigint_ti.get_type(),
1218 std::vector<std::shared_ptr<Analyzer::Expr>>
args = {datetime, rhs};
1219 auto dt_plus = makeExpr<Analyzer::FunctionOper>(
1226 const auto interval =
fold_expr(rhs.get());
1227 auto interval_ti = interval->get_type_info();
1231 std::shared_ptr<Analyzer::Expr> interval_sec;
1235 (op ==
kMINUS ? -interval_lit->get_constval().bigintval
1236 : interval_lit->get_constval().bigintval) /
1239 interval_sec = makeExpr<Analyzer::BinOper>(bigint_ti.get_type(),
1246 std::make_shared<Analyzer::UOper>(bigint_ti,
false,
kUMINUS, interval_sec);
1249 return makeExpr<Analyzer::DateaddExpr>(datetime_ti,
daSECOND, interval_sec, datetime);
1252 const auto interval_months = op ==
kMINUS ? std::make_shared<Analyzer::UOper>(
1253 bigint_ti,
false,
kUMINUS, interval)
1255 return makeExpr<Analyzer::DateaddExpr>(datetime_ti,
daMONTH, interval_months, datetime);
1285 return makeExpr<Analyzer::CharLengthExpr>(str_arg->decompress(),
1286 rex_function->
getName() ==
"CHAR_LENGTH"sv);
1294 if (
nullptr == expr || !expr->get_type_info().is_string() ||
1295 expr->get_type_info().is_varlen()) {
1296 throw std::runtime_error(rex_function->
getName() +
1297 " expects a dictionary encoded text column.");
1301 throw std::runtime_error(
1303 " does not support unnest operator as its input expression.");
1305 return makeExpr<Analyzer::KeyForStringExpr>(
args[0]);
1312 const auto& arg_ti = arg->get_type_info();
1313 if (arg_ti.get_type() !=
kDOUBLE) {
1315 arg = arg->add_cast(double_ti);
1317 return makeExpr<Analyzer::SampleRatioExpr>(arg);
1322 std::string user{
"SESSIONLESS_USER"};
1324 user =
query_state_->getConstSessionInfo()->get_currentUser().userName;
1331 const auto func_name = rex_function->
getName();
1333 std::ostringstream oss;
1334 oss <<
"Function " << func_name <<
" not supported.";
1335 throw std::runtime_error(oss.str());
1341 const auto& arg0_ti =
args[0]->get_type_info();
1342 if (arg0_ti.is_none_encoded_string()) {
1348 args[0] = makeExpr<Analyzer::UOper>(
1349 casted_target_ti,
args[0]->get_contains_agg(),
kCAST,
args[0]);
1353 switch (string_op_kind) {
1355 return makeExpr<Analyzer::LowerStringOper>(
args);
1357 return makeExpr<Analyzer::UpperStringOper>(
args);
1359 return makeExpr<Analyzer::InitCapStringOper>(
args);
1361 return makeExpr<Analyzer::ReverseStringOper>(
args);
1363 return makeExpr<Analyzer::RepeatStringOper>(
args);
1365 return makeExpr<Analyzer::ConcatStringOper>(
args);
1368 return makeExpr<Analyzer::PadStringOper>(string_op_kind,
args);
1373 return makeExpr<Analyzer::TrimStringOper>(string_op_kind,
args);
1376 return makeExpr<Analyzer::SubstringStringOper>(
args);
1378 return makeExpr<Analyzer::OverlayStringOper>(
args);
1380 return makeExpr<Analyzer::ReplaceStringOper>(
args);
1382 return makeExpr<Analyzer::SplitPartStringOper>(
args);
1384 return makeExpr<Analyzer::RegexpReplaceStringOper>(
args);
1386 return makeExpr<Analyzer::RegexpSubstrStringOper>(
args);
1388 throw std::runtime_error(
"Unsupported string function.");
1395 const auto ret_ti = rex_function->
getType();
1397 const auto arg_ti = arg->get_type_info();
1398 if (!arg_ti.is_array()) {
1399 throw std::runtime_error(rex_function->
getName() +
" expects an array expression.");
1401 if (arg_ti.get_subtype() ==
kARRAY) {
1402 throw std::runtime_error(rex_function->
getName() +
1403 " expects one-dimension array expression.");
1405 const auto array_size = arg_ti.get_size();
1406 const auto array_elem_size = arg_ti.get_elem_type().get_array_context_logical_size();
1408 if (array_size > 0) {
1409 if (array_elem_size <= 0) {
1410 throw std::runtime_error(rex_function->
getName() +
1411 ": unexpected array element type.");
1417 return makeExpr<Analyzer::CardinalityExpr>(arg);
1425 return makeExpr<Analyzer::BinOper>(
1426 base->get_type_info().get_elem_type(),
false,
kARRAY_AT,
kONE, base, index);
1430 constexpr
bool is_null =
false;
1433 return makeExpr<Analyzer::Constant>(
kDATE,
is_null, datum);
1437 constexpr
bool is_null =
false;
1440 return makeExpr<Analyzer::Constant>(
kTIME,
is_null, datum);
1452 const std::string datetime_err{R
"(Only DATETIME('NOW') supported for now.)"};
1453 if (!arg_lit || arg_lit->get_is_null()) {
1454 throw std::runtime_error(datetime_err);
1456 CHECK(arg_lit->get_type_info().is_string());
1457 if (*arg_lit->get_constval().stringval !=
"NOW"sv) {
1458 throw std::runtime_error(datetime_err);
1465 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
1469 const auto& operand_ti = operand->get_type_info();
1470 CHECK(operand_ti.is_number());
1472 const auto lt_zero = makeExpr<Analyzer::BinOper>(
kBOOLEAN,
kLT,
kONE, operand, zero);
1473 const auto uminus_operand =
1474 makeExpr<Analyzer::UOper>(operand_ti.get_type(),
kUMINUS, operand);
1475 expr_list.emplace_back(lt_zero, uminus_operand);
1476 return makeExpr<Analyzer::CaseExpr>(operand_ti,
false, expr_list, operand);
1481 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
1485 const auto& operand_ti = operand->get_type_info();
1486 CHECK(operand_ti.is_number());
1488 const auto lt_zero = makeExpr<Analyzer::BinOper>(
kBOOLEAN,
kLT,
kONE, operand, zero);
1490 const auto eq_zero = makeExpr<Analyzer::BinOper>(
kBOOLEAN,
kEQ,
kONE, operand, zero);
1492 const auto gt_zero = makeExpr<Analyzer::BinOper>(
kBOOLEAN,
kGT,
kONE, operand, zero);
1494 return makeExpr<Analyzer::CaseExpr>(
1498 makeExpr<Analyzer::Constant>(operand_ti,
true,
Datum{0}));
1502 return makeExpr<Analyzer::OffsetInFragment>();
1508 auto sql_type = rex_function->
getType();
1513 if (translated_function_args.size() > 0) {
1514 const auto first_element_logical_type =
1517 auto diff_elem_itr =
1518 std::find_if(translated_function_args.begin(),
1519 translated_function_args.end(),
1520 [first_element_logical_type](
const auto expr) {
1521 return first_element_logical_type !=
1524 if (diff_elem_itr != translated_function_args.end()) {
1525 throw std::runtime_error(
1527 std::to_string(diff_elem_itr - translated_function_args.begin()) +
1528 " is not of the same type as other elements of the array. Consider casting "
1529 "to force this condition.\nElement Type: " +
1532 "\nArray type: " + first_element_logical_type.to_string());
1535 if (first_element_logical_type.is_string() &&
1536 !first_element_logical_type.is_dict_encoded_string()) {
1537 sql_type.set_subtype(first_element_logical_type.get_type());
1539 }
else if (first_element_logical_type.is_dict_encoded_string()) {
1540 sql_type.set_subtype(first_element_logical_type.get_type());
1543 sql_type.set_subtype(first_element_logical_type.get_type());
1544 sql_type.set_scale(first_element_logical_type.get_scale());
1545 sql_type.set_precision(first_element_logical_type.get_precision());
1548 return makeExpr<Analyzer::ArrayExpr>(sql_type, translated_function_args);
1552 return makeExpr<Analyzer::ArrayExpr>(sql_type, translated_function_args);
1555 return makeExpr<Analyzer::ArrayExpr>(rex_function->
getType(),
1565 if (rex_function->
getName() ==
"REGEXP_LIKE"sv) {
1568 if (rex_function->
getName() ==
"LIKELY"sv) {
1571 if (rex_function->
getName() ==
"UNLIKELY"sv) {
1577 if (rex_function->
getName() ==
"DATEADD"sv) {
1580 if (rex_function->
getName() ==
"DATEDIFF"sv) {
1583 if (rex_function->
getName() ==
"DATEPART"sv) {
1589 if (rex_function->
getName() ==
"KEY_FOR_STRING"sv) {
1592 if (rex_function->
getName() ==
"WIDTH_BUCKET"sv) {
1595 if (rex_function->
getName() ==
"SAMPLE_RATIO"sv) {
1598 if (rex_function->
getName() ==
"CURRENT_USER"sv) {
1619 "REGEXP_MATCH"sv)) {
1625 if (rex_function->
getName() ==
"ITEM"sv) {
1628 if (rex_function->
getName() ==
"CURRENT_DATE"sv) {
1631 if (rex_function->
getName() ==
"CURRENT_TIME"sv) {
1634 if (rex_function->
getName() ==
"CURRENT_TIMESTAMP"sv) {
1637 if (rex_function->
getName() ==
"NOW"sv) {
1640 if (rex_function->
getName() ==
"DATETIME"sv) {
1646 if (rex_function->
getName() ==
"ABS"sv) {
1649 if (rex_function->
getName() ==
"SIGN"sv) {
1653 return makeExpr<Analyzer::FunctionOperWithCustomTypeHandling>(
1657 }
else if (rex_function->
getName() ==
"ROUND"sv) {
1658 std::vector<std::shared_ptr<Analyzer::Expr>>
args =
1661 if (rex_function->
size() == 1) {
1669 args.push_back(makeExpr<Analyzer::Constant>(t,
false, d));
1673 CHECK(args.size() == 2);
1675 if (!args[0]->get_type_info().is_number()) {
1676 throw std::runtime_error(
"Only numeric 1st operands are supported");
1681 if (!args[1]->get_type_info().is_integer()) {
1682 throw std::runtime_error(
"Only integer 2nd operands are supported");
1689 ? args[0]->get_type_info()
1692 return makeExpr<Analyzer::FunctionOperWithCustomTypeHandling>(
1695 if (rex_function->
getName() ==
"DATETIME_PLUS"sv) {
1696 auto dt_plus = makeExpr<Analyzer::FunctionOper>(rex_function->
getType(),
1705 if (rex_function->
getName() ==
"/INT"sv) {
1712 if (rex_function->
getName() ==
"Reinterpret"sv) {
1729 "HeavyDB_Geo_PolyBoundsPtr"sv,
1730 "HeavyDB_Geo_PolyRenderGroup"sv)) {
1735 "convert_meters_to_pixel_width"sv,
1736 "convert_meters_to_pixel_height"sv,
1737 "is_point_in_view"sv,
1738 "is_point_size_in_view"sv)) {
1748 "ST_Approx_Overlaps"sv,
1757 if (rex_function->
getName() ==
"OFFSET_IN_FRAGMENT"sv) {
1761 if (rex_function->
getName() ==
"ARRAY"sv) {
1766 "ST_GeomFromText"sv,
1767 "ST_GeogFromText"sv,
1774 "ST_Transform"sv)) {
1779 "ST_Intersection"sv,
1795 return distance_check;
1802 if (rex_function->
getName() == std::string(
"||") ||
1803 rex_function->
getName() == std::string(
"SUBSTRING")) {
1805 return makeExpr<Analyzer::FunctionOper>(
1806 ret_ti, rex_function->
getName(), arg_expr_list);
1817 auto ext_func_args = ext_func_sig.getInputArgs();
1818 CHECK_EQ(arg_expr_list.size(), ext_func_args.size());
1819 for (
size_t i = 0; i < arg_expr_list.size(); i++) {
1822 std::dynamic_pointer_cast<Analyzer::Constant>(arg_expr_list[i])) {
1824 if (ext_func_arg_ti != arg_expr_list[i]->get_type_info()) {
1825 arg_expr_list[i] = constant->add_cast(ext_func_arg_ti);
1832 LOG(
WARNING) <<
"RelAlgTranslator::translateFunction: " << e.what();
1838 bool arguments_not_null =
true;
1839 for (
const auto& arg_expr : arg_expr_list) {
1840 if (!arg_expr->get_type_info().get_notnull()) {
1841 arguments_not_null =
false;
1847 return makeExpr<Analyzer::FunctionOper>(ret_ti, rex_function->
getName(), arg_expr_list);
1853 const std::vector<SortField>& sort_fields) {
1854 std::vector<Analyzer::OrderEntry> collation;
1855 for (
size_t i = 0; i < sort_fields.size(); ++i) {
1856 const auto& sort_field = sort_fields[i];
1857 collation.emplace_back(i,
1867 std::vector<std::shared_ptr<Analyzer::Expr>>
args;
1868 for (
size_t i = 0; i < rex_window_function->
size(); ++i) {
1871 std::vector<std::shared_ptr<Analyzer::Expr>> partition_keys;
1872 for (
const auto& partition_key : rex_window_function->
getPartitionKeys()) {
1875 std::vector<std::shared_ptr<Analyzer::Expr>> order_keys;
1876 for (
const auto& order_key : rex_window_function->
getOrderKeys()) {
1879 auto ti = rex_window_function->
getType();
1882 ti = args.front()->get_type_info();
1884 bool has_framing_clause =
true;
1885 switch (rex_window_function->
getKind()) {
1894 VLOG(1) <<
"Window framing is ignored: given window function "
1895 << rex_window_function->
getName() +
" operates on an entire partition";
1896 has_framing_clause =
false;
1902 auto determine_frame_bound_type =
1904 if (bound.unbounded) {
1905 CHECK(!bound.bound_expr && !bound.is_current_row);
1906 if (bound.following) {
1908 }
else if (bound.preceding) {
1912 if (bound.is_current_row) {
1913 CHECK(!bound.unbounded && !bound.bound_expr);
1916 CHECK(!bound.unbounded && bound.bound_expr);
1917 if (bound.following) {
1919 }
else if (bound.preceding) {
1927 bool negative_constant =
false;
1930 bool has_end_bound_frame_expr =
false;
1931 std::shared_ptr<Analyzer::Expr> frame_start_bound_expr;
1933 determine_frame_bound_type(frame_start_bound);
1934 std::shared_ptr<Analyzer::Expr> frame_end_bound_expr;
1936 determine_frame_bound_type(frame_end_bound);
1937 auto frame_mode = rex_window_function->
isRows()
1940 if (order_keys.empty()) {
1947 has_framing_clause =
false;
1948 LOG(
INFO) <<
"The frame clause is ignored in row mode when no order by clause is "
1957 has_framing_clause =
false;
1960 auto order_key_expr = order_keys.front();
1961 auto is_negative_framing_bound = [&](
const SQLTypes t,
const Datum& d) {
1964 return d.tinyintval < 0;
1967 return d.smallintval < 0;
1970 return d.intval < 0;
1973 return d.bigintval < 0;
1976 throw std::runtime_error(
1977 "We currently only support integer-type literal expression as a window "
1986 if (frame_start_bound.bound_expr) {
1988 if (
auto literal_expr =
1989 dynamic_cast<const Analyzer::Constant*>(frame_start_bound_expr.get())) {
1990 negative_constant = is_negative_framing_bound(
1991 literal_expr->get_type_info().get_type(), literal_expr->get_constval());
1993 throw std::runtime_error(
1994 "We currently only support integer-type literal expression as a window frame "
2000 if (frame_end_bound.bound_expr) {
2001 has_end_bound_frame_expr =
true;
2003 if (
auto literal_expr =
2004 dynamic_cast<const Analyzer::Constant*>(frame_end_bound_expr.get())) {
2005 negative_constant = is_negative_framing_bound(
2006 literal_expr->get_type_info().get_type(), literal_expr->get_constval());
2008 throw std::runtime_error(
2009 "We currently only support integer-type literal expression as a window frame "
2017 if (negative_constant) {
2018 throw std::runtime_error(
2019 "A constant expression for window framing should have nonnegative value.");
2022 if (frame_start_bound.following) {
2023 if (frame_end_bound.is_current_row) {
2024 throw std::runtime_error(
2025 "Window framing starting from following row cannot end with current row.");
2026 }
else if (has_end_bound_frame_expr && frame_end_bound.preceding) {
2027 throw std::runtime_error(
2028 "Window framing starting from following row cannot have preceding rows.");
2031 if (frame_start_bound.is_current_row && frame_end_bound.preceding &&
2032 !frame_end_bound.unbounded && has_end_bound_frame_expr) {
2033 throw std::runtime_error(
2034 "Window framing starting from current row cannot have preceding rows.");
2036 if (has_framing_clause) {
2038 if (order_keys.size() > 1) {
2039 throw std::runtime_error(
2040 "Window framing with range mode requires a single order-by column");
2042 if (!frame_start_bound_expr &&
2044 !frame_end_bound_expr &&
2046 has_framing_clause =
false;
2047 VLOG(1) <<
"Ignore range framing mode with a frame bound between "
2048 "UNBOUNDED_PRECEDING and CURRENT_ROW";
2051 bool (*)(
const Analyzer::ColumnVar*,
const Analyzer::ColumnVar*)>
2054 for (
auto cv : colvar_set) {
2055 if (!(cv->get_type_info().is_integer() || cv->get_type_info().is_fp())) {
2056 has_framing_clause =
false;
2057 VLOG(1) <<
"Range framing mode with non-number type ordering column is not "
2058 "supported yet, skip window framing";
2063 if (!has_framing_clause) {
2066 frame_start_bound_expr =
nullptr;
2067 frame_end_bound_expr =
nullptr;
2069 return makeExpr<Analyzer::WindowFunction>(
2071 rex_window_function->
getKind(),
2076 makeExpr<Analyzer::WindowFrame>(frame_start_bound_type, frame_start_bound_expr),
2077 makeExpr<Analyzer::WindowFrame>(frame_end_bound_type, frame_end_bound_expr),
2083 std::vector<std::shared_ptr<Analyzer::Expr>>
args;
2084 for (
size_t i = 0; i < rex_function->
size(); ++i) {
2091 const std::shared_ptr<Analyzer::Expr> qual_expr) {
2095 const auto rewritten_qual_expr =
rewrite_expr(qual_expr.get());
2096 return {{}, {rewritten_qual_expr ? rewritten_qual_expr : qual_expr}};
2099 if (bin_oper->get_optype() ==
kAND) {
2103 simple_quals.insert(
2104 simple_quals.end(), rhs_cf.simple_quals.begin(), rhs_cf.simple_quals.end());
2105 auto quals = lhs_cf.quals;
2106 quals.insert(quals.end(), rhs_cf.quals.begin(), rhs_cf.quals.end());
2107 return {simple_quals, quals};
2110 const auto simple_qual = bin_oper->normalize_simple_predicate(rte_idx);
2116 const std::shared_ptr<Analyzer::Expr>& qual_expr) {
2118 const auto bin_oper = std::dynamic_pointer_cast<
const Analyzer::BinOper>(qual_expr);
2120 const auto rewritten_qual_expr =
rewrite_expr(qual_expr.get());
2121 return {rewritten_qual_expr ? rewritten_qual_expr : qual_expr};
2123 if (bin_oper->get_optype() ==
kOR) {
2126 auto quals = lhs_df;
2127 quals.insert(quals.end(), rhs_df.begin(), rhs_df.end());
2143 const auto& operand_ti = operand->get_type_info();
2144 const auto& target_ti = rex_function->
getType();
2145 if (!operand_ti.is_string()) {
2146 throw std::runtime_error(
2147 "High precision timestamp cast argument must be a string. Input type is: " +
2148 operand_ti.get_type_name());
2149 }
else if (!target_ti.is_high_precision_timestamp()) {
2150 throw std::runtime_error(
2151 "Cast target type should be high precision timestamp. Input type is: " +
2152 target_ti.get_type_name());
2153 }
else if (target_ti.get_dimension() != 6 && target_ti.get_dimension() != 9) {
2154 throw std::runtime_error(
2155 "Cast target type should be TIMESTAMP(6|9). Input type is: TIMESTAMP(" +
2158 return operand->add_cast(target_ti);
DEVICE auto upper_bound(ARGS &&...args)
Defines data structures for the semantic analysis phase of query processing.
const RexScalar * getThen(const size_t idx) const
const std::vector< JoinType > join_types_
HOST DEVICE SQLTypes get_subtype() const
void set_compression(EncodingType c)
static std::shared_ptr< Analyzer::Expr > normalize(const std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr >>> &, const std::shared_ptr< Analyzer::Expr >, const Executor *executor=nullptr)
std::shared_ptr< Analyzer::Expr > translateOffsetInFragment() const
SqlStringOpKind name_to_string_op_kind(const std::string &func_name)
static std::shared_ptr< Analyzer::Expr > get(const std::string &)
std::shared_ptr< Analyzer::Expr > translateCurrentTimestamp() const
std::shared_ptr< Analyzer::Expr > translateBinaryGeoPredicate(const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr > translateRegexp(const RexFunctionOperator *) const
static bool colvar_comp(const ColumnVar *l, const ColumnVar *r)
const size_t g_max_integer_set_size
size_t getOperand(size_t idx) const
const Executor * executor_
std::shared_ptr< Analyzer::Expr > translateUnlikely(const RexFunctionOperator *) const
const RexScalar * getElse() const
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
static std::shared_ptr< Analyzer::Expr > analyzeValue(const int64_t intval)
std::shared_ptr< Analyzer::Expr > translateFunction(const RexFunctionOperator *) const
SQLTypeInfo get_nullable_logical_type_info(const SQLTypeInfo &type_info)
std::shared_ptr< Analyzer::Expr > translateScalarRex(const RexScalar *rex) const
const SQLTypeInfo & getType() const
const RexScalar * getOperand(const size_t idx) const
std::shared_ptr< Analyzer::Expr > translateUoper(const RexOperator *) const
HOST DEVICE int get_scale() const
const std::vector< SortField > & getCollation() const
std::shared_ptr< Analyzer::Expr > translateDateadd(const RexFunctionOperator *) const
static std::shared_ptr< Analyzer::Expr > normalize(const SQLOps optype, const SQLQualifier qual, std::shared_ptr< Analyzer::Expr > left_expr, std::shared_ptr< Analyzer::Expr > right_expr, const Executor *executor=nullptr)
std::shared_ptr< Analyzer::Expr > translateAbs(const RexFunctionOperator *) const
const RexScalar * getWhen(const size_t idx) const
std::shared_ptr< Analyzer::Expr > ExpressionPtr
std::string getString(int32_t string_id) const
std::shared_ptr< Analyzer::Expr > getInIntegerSetExpr(std::shared_ptr< Analyzer::Expr > arg, const ResultSet &val_set) const
SQLTypeInfo get_agg_type(const SQLAgg agg_kind, const Analyzer::Expr *arg_expr)
std::shared_ptr< Analyzer::Expr > translateItem(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Constant > makeNumericConstant(const SQLTypeInfo &ti, const long val)
Analyzer::ExpressionPtr rewrite_expr(const Analyzer::Expr *expr)
HOST DEVICE SQLTypes get_type() const
QualsConjunctiveForm qual_to_conjunctive_form(const std::shared_ptr< Analyzer::Expr > qual_expr)
bool is_agg_supported_for_type(const SQLAgg &agg_kind, const SQLTypeInfo &arg_ti)
std::shared_ptr< Analyzer::Expr > translateGeoProjection(const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
double inline_fp_null_val(const SQL_TYPE_INFO &ti)
std::shared_ptr< Analyzer::Expr > translateOper(const RexOperator *) const
std::shared_ptr< Analyzer::Expr > translateDatediff(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateInput(const RexInput *) const
std::shared_ptr< Analyzer::Expr > translateSign(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateUnaryGeoFunction(const RexFunctionOperator *) const
bool g_enable_string_functions
std::shared_ptr< Analyzer::Expr > translateGeoOverlapsOper(const RexOperator *) const
ExtractField to_datepart_field(const std::string &field)
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Supported runtime functions management and retrieval.
future< Result > async(Fn &&fn, Args &&...args)
static std::shared_ptr< Analyzer::Expr > translateLiteral(const RexLiteral *)
SQLOps getOperator() const
bool window_function_is_value(const SqlWindowFunctionKind kind)
static constexpr int32_t INVALID_STR_ID
CONSTEXPR DEVICE bool is_null(const T &value)
Classes representing a parse tree.
std::shared_ptr< Analyzer::Expr > translateDatetime(const RexFunctionOperator *) const
void fill_dictionary_encoded_in_vals(std::vector< int64_t > &in_vals, std::atomic< size_t > &total_in_vals_count, const ResultSet *values_rowset, const std::pair< int64_t, int64_t > values_rowset_slice, const StringDictionaryProxy *source_dict, const StringDictionaryProxy *dest_dict, const int64_t needle_null_val)
std::shared_ptr< Analyzer::Expr > translateStringOper(const RexFunctionOperator *) const
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, std::shared_ptr< Analyzer::Expr > pattern_expr, std::shared_ptr< Analyzer::Expr > escape_expr, const bool is_not)
std::vector< Analyzer::OrderEntry > translate_collation(const std::vector< SortField > &sort_fields)
size_t branchCount() const
std::shared_ptr< Analyzer::Expr > translateCurrentTime() const
int getDatabaseId() const
SQLTypeInfo build_type_info(const SQLTypes sql_type, const int scale, const int precision)
DatetruncField to_datediff_field(const std::string &field)
void translate_string_ids(std::vector< int32_t > &dest_ids, const LeafHostInfo &dict_server_host, const DictRef dest_dict_ref, const std::vector< int32_t > &source_ids, const DictRef source_dict_ref, const int32_t dest_generation)
const RexWindowBound & getFrameEndBound() const
const std::vector< LeafHostInfo > & getStringDictionaryHosts() const
std::tuple< T, std::vector< SQLTypeInfo > > bind_function(std::string name, Analyzer::ExpressionPtrVector func_args, const std::vector< T > &ext_funcs, const std::string processor)
const ColumnDescriptor * getMetadataForColumnBySpi(const int tableId, const size_t spi) const
Argument type based extension function binding.
const std::unordered_map< const RelAlgNode *, int > input_to_nest_level_
std::pair< std::shared_ptr< Analyzer::Expr >, SQLQualifier > get_quantified_rhs(const RexScalar *rex_scalar, const RelAlgTranslator &translator)
void set_comp_param(int p)
Analyzer::ExpressionPtrVector translateFunctionArgs(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateUnaryGeoPredicate(const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
const ConstRexScalarPtrVector & getPartitionKeys() const
#define TRANSIENT_DICT_ID
static std::shared_ptr< Analyzer::Expr > analyzeValue(const std::string &stringval, const bool is_null)
DEVICE auto lower_bound(ARGS &&...args)
const RexWindowBound & getFrameStartBound() const
std::shared_ptr< Analyzer::Expr > translateOverlapsOper(const RexOperator *) const
std::shared_ptr< Analyzer::Expr > translateArrayFunction(const RexFunctionOperator *) const
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, std::shared_ptr< Analyzer::Expr > like_expr, std::shared_ptr< Analyzer::Expr > escape_expr, const bool is_ilike, const bool is_not)
static RelRexToStringConfig defaults()
std::shared_ptr< Analyzer::Expr > translateCurrentUser(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateSampleRatio(const RexFunctionOperator *) const
SqlWindowFunctionKind getKind() const
std::shared_ptr< Analyzer::Expr > translateLike(const RexFunctionOperator *) const
bool takes_arg(const TargetInfo &target_info)
static std::shared_ptr< Analyzer::Expr > analyzeValue(const int64_t numericval, const int scale, const int precision)
std::shared_ptr< Analyzer::Expr > translateLikely(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > get_in_values_expr(std::shared_ptr< Analyzer::Expr > arg, const ResultSet &val_set)
static std::shared_ptr< Analyzer::Expr > get(const int64_t)
std::shared_ptr< Analyzer::Expr > translateTernaryGeoFunction(const RexFunctionOperator *) const
const ConstRexScalarPtrVector & getOrderKeys() const
std::vector< std::shared_ptr< Analyzer::Expr > > qual_to_disjunctive_form(const std::shared_ptr< Analyzer::Expr > &qual_expr)
std::shared_ptr< Analyzer::Expr > translateBinaryGeoFunction(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Constant > make_fp_constant(const int64_t val, const SQLTypeInfo &ti)
std::pair< Datum, bool > datum_from_scalar_tv(const ScalarTargetValue *scalar_tv, const SQLTypeInfo &ti) noexcept
std::shared_ptr< Analyzer::Expr > translateWidthBucket(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateInOper(const RexOperator *) const
uint64_t exp_to_scale(const unsigned exp)
int64_t inline_int_null_val(const SQL_TYPE_INFO &ti)
std::vector< ExpressionPtr > ExpressionPtrVector
std::shared_ptr< Analyzer::Expr > translateCase(const RexCase *) const
std::shared_ptr< Analyzer::Expr > translateFunctionWithGeoArg(const RexFunctionOperator *) const
std::shared_ptr< const query_state::QueryState > query_state_
const std::string & getName() const
std::shared_ptr< Analyzer::Expr > translateCurrentDate() const
std::string get_datetimeplus_rewrite_funcname(const SQLOps &op)
void validate_datetime_datepart_argument(const std::shared_ptr< Analyzer::Constant > literal_expr)
std::shared_ptr< Analyzer::Expr > translateCardinality(const RexFunctionOperator *) const
const std::vector< TargetMetaInfo > & getOutputMetainfo() const
std::shared_ptr< Analyzer::Expr > translateGeoComparison(const RexOperator *) const
std::shared_ptr< Analyzer::Expr > translateDatePlusMinus(const RexOperator *) const
std::shared_ptr< Analyzer::Expr > translateHPTLiteral(const RexFunctionOperator *) const
bool is_distinct(const size_t input_idx, const RelAlgNode *node)
int32_t getIdOfString(const std::string &str) const
std::shared_ptr< Analyzer::Expr > translateDatepart(const RexFunctionOperator *) const
bool can_use_parallel_algorithms(const ResultSet &rows)
std::shared_ptr< Analyzer::Expr > translateBinaryGeoConstructor(const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr > rewrite_to_date_trunc(const Analyzer::FunctionOper *dt_plus)
SQLTypeInfo ext_arg_type_to_type_info(const ExtArgumentType ext_arg_type)
DateaddField to_dateadd_field(const std::string &field)
std::shared_ptr< Analyzer::Expr > fold_expr(const Analyzer::Expr *expr)
void set_precision(int d)
void fill_integer_in_vals(std::vector< int64_t > &in_vals, std::atomic< size_t > &total_in_vals_count, const ResultSet *values_rowset, const std::pair< int64_t, int64_t > values_rowset_slice)
const Catalog_Namespace::Catalog & cat_
std::shared_ptr< Analyzer::Expr > translateKeyForString(const RexFunctionOperator *) const
static std::shared_ptr< Analyzer::Expr > translateAggregateRex(const RexAgg *rex, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
std::shared_ptr< Analyzer::Expr > translateWindowFunction(const RexWindowFunctionOperator *) const
const std::shared_ptr< Analyzer::Expr > generate() const
std::shared_ptr< Analyzer::Expr > translateScalarSubquery(const RexSubQuery *) const
boost::variant< int64_t, double, float, NullableString > ScalarTargetValue
std::shared_ptr< Analyzer::Expr > translateLength(const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr > translateExtract(const RexFunctionOperator *) const
HOST DEVICE void set_type(SQLTypes t)