27 #include <rapidjson/error/en.h>
28 #include <rapidjson/error/error.h>
29 #include <rapidjson/stringbuffer.h>
30 #include <rapidjson/writer.h>
33 #include <unordered_set>
51 const std::shared_ptr<const ExecutionResult>
result) {
52 auto row_set = result->getRows();
54 CHECK_EQ(
size_t(1), row_set->colCount());
55 *(type_.get()) = row_set->getColType(0);
56 (*(result_.get())) =
result;
60 return std::make_unique<RexSubQuery>(type_, result_, ra_->deepCopy());
72 : old_input_(old_input), new_input_(new_input) {}
78 if (old_source == old_input_) {
96 std::vector<RexInput> outputs;
98 for (
size_t i = 0; i <
n; ++i) {
99 outputs.emplace_back(node, i);
109 std::unordered_map<unsigned, unsigned> old_to_new_index_map)
113 RexRebindInputsVisitor::visitInput(rex_input);
114 auto mapping_itr = mapping_.find(rex_input->
getIndex());
115 CHECK(mapping_itr != mapping_.end());
116 rex_input->
setIndex(mapping_itr->second);
121 const std::unordered_map<unsigned, unsigned>
mapping_;
129 std::shared_ptr<RelProject> new_project,
130 std::vector<std::unique_ptr<const RexScalar>>& scalar_exprs_for_new_project,
131 std::vector<std::string>& fields_for_new_project,
132 std::unordered_map<size_t, size_t>& expr_offset_cache)
133 : new_project_(new_project)
134 , scalar_exprs_for_new_project_(scalar_exprs_for_new_project)
135 , fields_for_new_project_(fields_for_new_project)
136 , expr_offset_cache_(expr_offset_cache)
137 , found_case_expr_window_operand_(
false)
138 , has_partition_expr_(
false) {}
141 auto hash = expr->
toHash();
142 auto it = expr_offset_cache_.find(hash);
143 auto new_offset = -1;
144 if (it == expr_offset_cache_.end()) {
146 expr_offset_cache_.emplace(hash, scalar_exprs_for_new_project_.size()).second);
147 new_offset = scalar_exprs_for_new_project_.size();
148 fields_for_new_project_.emplace_back(
"");
149 scalar_exprs_for_new_project_.emplace_back(deep_copier_.visit(expr));
152 new_offset = it->second;
158 size_t expr_offset)
const {
162 case WindowExprType::PARTITION_KEY: {
163 auto it = pushed_down_partition_key_offset_.find(expr_offset);
164 CHECK(it != pushed_down_partition_key_offset_.end());
167 case WindowExprType::ORDER_KEY: {
168 auto it = pushed_down_order_key_offset_.find(expr_offset);
169 CHECK(it != pushed_down_order_key_offset_.end());
185 pushed_down_window_operands_offset_.clear();
186 pushed_down_partition_key_offset_.clear();
187 pushed_down_order_key_offset_.clear();
188 for (
size_t offset = 0; offset < window_expr->
size(); ++offset) {
190 auto literal_expr =
dynamic_cast<const RexLiteral*
>(expr);
191 auto case_expr =
dynamic_cast<const RexCase*
>(expr);
197 found_case_expr_window_operand_ =
true;
200 auto new_offset = pushDownExpressionImpl(expr);
201 pushed_down_window_operands_offset_.emplace(offset, new_offset);
206 auto new_offset = pushDownExpressionImpl(partition_key.get());
207 pushed_down_partition_key_offset_.emplace(offset, new_offset);
212 for (
const auto& order_key : window_expr->
getOrderKeys()) {
213 auto new_offset = pushDownExpressionImpl(order_key.get());
214 pushed_down_order_key_offset_.emplace(offset, new_offset);
220 std::vector<std::unique_ptr<const RexScalar>> window_operands;
222 for (
size_t idx = 0; idx < window_expr->
size(); ++idx) {
223 auto it = pushed_down_window_operands_offset_.find(idx);
224 if (it != pushed_down_window_operands_offset_.end()) {
225 auto new_input = std::make_unique<const RexInput>(new_project_.get(), it->second);
227 window_operands.emplace_back(std::move(new_input));
229 auto copied_expr = deep_copier_.visit(window_expr->
getOperand(idx));
230 window_operands.emplace_back(std::move(copied_expr));
233 deconst_window_expr->replaceOperands(std::move(window_operands));
236 auto new_offset = getOffsetForPushedDownExpr(WindowExprType::PARTITION_KEY, idx);
238 auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
240 deconst_window_expr->replacePartitionKey(idx, std::move(new_input));
243 for (
size_t idx = 0; idx < window_expr->
getOrderKeys().size(); ++idx) {
244 auto new_offset = getOffsetForPushedDownExpr(WindowExprType::ORDER_KEY, idx);
246 auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
248 deconst_window_expr->replaceOrderKey(idx, std::move(new_input));
253 auto new_offset = pushDownExpressionImpl(rex_input);
254 CHECK_LT(new_offset, scalar_exprs_for_new_project_.size());
255 auto hash = rex_input->
toHash();
256 auto it = expr_offset_cache_.find(hash);
257 CHECK(it != expr_offset_cache_.end());
259 auto new_input = std::make_unique<const RexInput>(new_project_.get(), new_offset);
265 const RexLiteral* rex_literal)
const override {
266 return deep_copier_.visit(rex_literal);
269 std::unique_ptr<const RexScalar>
visitRef(
const RexRef* rex_ref)
const override {
270 return deep_copier_.visit(rex_ref);
274 const RexSubQuery* rex_subquery)
const override {
275 return deep_copier_.visit(rex_subquery);
280 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
282 std::unique_ptr<const RexScalar> new_else_expr;
283 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
284 const auto when = rex_case->
getWhen(i);
285 auto new_when = PushDownGenericExpressionInWindowFunction::visit(when);
286 const auto then = rex_case->
getThen(i);
287 auto new_then = PushDownGenericExpressionInWindowFunction::visit(then);
288 new_expr_pair_list.emplace_back(std::move(new_when), std::move(new_then));
291 new_else_expr = deep_copier_.visit(rex_case->
getElse());
293 auto new_case = std::make_unique<const RexCase>(new_expr_pair_list, new_else_expr);
299 const auto rex_window_func_operator =
301 if (rex_window_func_operator) {
302 pushDownExpressionInWindowFunction(rex_window_func_operator);
303 return deep_copier_.visit(rex_operator);
305 std::unique_ptr<const RexOperator> new_operator{
nullptr};
306 std::vector<std::unique_ptr<const RexScalar>> new_operands;
307 for (
size_t i = 0; i < rex_operator->
size(); ++i) {
308 const auto operand = rex_operator->
getOperand(i);
309 auto new_operand = PushDownGenericExpressionInWindowFunction::visit(operand);
310 new_operands.emplace_back(std::move(new_operand));
312 if (
auto function_op = dynamic_cast<const RexFunctionOperator*>(rex_operator)) {
313 new_operator = std::make_unique<const RexFunctionOperator>(
314 function_op->getName(), new_operands, rex_operator->
getType());
316 new_operator = std::make_unique<const RexOperator>(
329 std::unique_ptr<const RexScalar>
defaultResult()
const override {
return nullptr; }
346 std::shared_ptr<const RelAlgNode> old_input,
347 std::shared_ptr<const RelAlgNode> input,
348 std::optional<std::unordered_map<unsigned, unsigned>> old_to_new_index_map) {
350 std::unique_ptr<RexRebindInputsVisitor> rebind_inputs;
351 if (old_to_new_index_map) {
352 rebind_inputs = std::make_unique<RexRebindReindexInputsVisitor>(
353 old_input.get(), input.get(), *old_to_new_index_map);
356 std::make_unique<RexRebindInputsVisitor>(old_input.get(), input.get());
358 CHECK(rebind_inputs);
360 rebind_inputs->visit(scalar_expr.get());
365 std::unique_ptr<const RexScalar> new_input) {
366 fields_.emplace_back(std::move(new_field_name));
371 const auto scan_node =
dynamic_cast<const RelScan*
>(ra_node);
374 CHECK_EQ(
size_t(0), scan_node->inputCount());
375 return n_outputs(scan_node, scan_node->size());
377 const auto project_node =
dynamic_cast<const RelProject*
>(ra_node);
380 CHECK_EQ(
size_t(1), project_node->inputCount());
381 return n_outputs(project_node, project_node->size());
383 const auto filter_node =
dynamic_cast<const RelFilter*
>(ra_node);
386 CHECK_EQ(
size_t(1), filter_node->inputCount());
388 return n_outputs(filter_node, prev_out.size());
390 const auto aggregate_node =
dynamic_cast<const RelAggregate*
>(ra_node);
391 if (aggregate_node) {
393 CHECK_EQ(
size_t(1), aggregate_node->inputCount());
394 return n_outputs(aggregate_node, aggregate_node->size());
396 const auto compound_node =
dynamic_cast<const RelCompound*
>(ra_node);
399 CHECK_EQ(
size_t(1), compound_node->inputCount());
400 return n_outputs(compound_node, compound_node->size());
402 const auto join_node =
dynamic_cast<const RelJoin*
>(ra_node);
406 CHECK_EQ(
size_t(2), join_node->inputCount());
411 lhs_out.insert(lhs_out.end(), rhs_out.begin(), rhs_out.end());
414 const auto table_func_node =
dynamic_cast<const RelTableFunction*
>(ra_node);
415 if (table_func_node) {
417 return n_outputs(table_func_node, table_func_node->size());
419 const auto sort_node =
dynamic_cast<const RelSort*
>(ra_node);
422 CHECK_EQ(
size_t(1), sort_node->inputCount());
424 return n_outputs(sort_node, prev_out.size());
426 const auto logical_values_node =
dynamic_cast<const RelLogicalValues*
>(ra_node);
427 if (logical_values_node) {
428 CHECK_EQ(
size_t(0), logical_values_node->inputCount());
429 return n_outputs(logical_values_node, logical_values_node->size());
431 const auto logical_union_node =
dynamic_cast<const RelLogicalUnion*
>(ra_node);
432 if (logical_union_node) {
433 return n_outputs(logical_union_node, logical_union_node->size());
445 if (dynamic_cast<const RelJoin*>(source)) {
454 const auto input =
dynamic_cast<const RexInput*
>(scalar_expr.get());
456 CHECK_EQ(source, input->getSourceNode());
460 if (input->getSourceNode() != source_shape[i].getSourceNode()) {
471 const std::string& new_name) {
473 if (
auto join = dynamic_cast<const RelJoin*>(node)) {
475 const auto lhs_size =
join->getInput(0)->size();
476 if (index < lhs_size) {
483 if (
auto scan = dynamic_cast<const RelScan*>(node)) {
484 return new_name != scan->getFieldName(index);
487 if (
auto aggregate = dynamic_cast<const RelAggregate*>(node)) {
488 return new_name != aggregate->getFieldName(index);
491 if (
auto project = dynamic_cast<const RelProject*>(node)) {
492 return new_name != project->getFieldName(index);
495 if (
auto table_func = dynamic_cast<const RelTableFunction*>(node)) {
496 return new_name != table_func->getFieldName(index);
499 if (
auto logical_values = dynamic_cast<const RelLogicalValues*>(node)) {
500 const auto& tuple_type = logical_values->getTupleType();
502 return new_name != tuple_type[index].get_resname();
505 CHECK(dynamic_cast<const RelSort*>(node) || dynamic_cast<const RelFilter*>(node) ||
506 dynamic_cast<const RelLogicalUnion*>(node));
517 for (
size_t i = 0; i <
fields_.size(); ++i) {
528 std::shared_ptr<const RelAlgNode> input) {
530 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
537 std::shared_ptr<const RelAlgNode> input) {
539 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
540 rebind_inputs.visit(
filter_.get());
544 std::shared_ptr<const RelAlgNode> input) {
546 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
548 rebind_inputs.visit(scalar_source.get());
558 , fields_(rhs.fields_)
559 , hint_applied_(
false)
560 , hints_(std::make_unique<
Hints>()) {
566 for (
auto const& kv : *rhs.
hints_) {
574 , tuple_type_(rhs.tuple_type_)
584 , groupby_count_(rhs.groupby_count_)
585 , fields_(rhs.fields_)
586 , hint_applied_(
false)
587 , hints_(std::make_unique<
Hints>()) {
593 for (
auto const& kv : *rhs.
hints_) {
601 , join_type_(rhs.join_type_)
602 , hint_applied_(
false)
603 , hints_(std::make_unique<
Hints>()) {
607 for (
auto const& kv : *rhs.
hints_) {
616 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs) {
617 std::vector<std::unique_ptr<const RexAgg>> agg_exprs_copy;
618 agg_exprs_copy.reserve(agg_exprs.size());
619 for (
auto const& agg_expr : agg_exprs) {
620 agg_exprs_copy.push_back(agg_expr->deepCopy());
622 return agg_exprs_copy;
626 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources) {
627 std::vector<std::unique_ptr<const RexScalar>> scalar_sources_copy;
628 scalar_sources_copy.reserve(scalar_sources.size());
630 for (
auto const& scalar_source : scalar_sources) {
631 scalar_sources_copy.push_back(copier.
visit(scalar_source.get()));
633 return scalar_sources_copy;
637 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs_new,
638 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources_new,
639 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs_old,
640 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources_old,
641 std::vector<const Rex*>
const& target_exprs_old) {
642 std::vector<const Rex*> target_exprs(target_exprs_old);
643 std::unordered_map<const Rex*, const Rex*> old_to_new_target(target_exprs.size());
644 for (
size_t i = 0; i < agg_exprs_new.size(); ++i) {
645 old_to_new_target.emplace(agg_exprs_old[i].
get(), agg_exprs_new[i].
get());
647 for (
size_t i = 0; i < scalar_sources_new.size(); ++i) {
648 old_to_new_target.emplace(scalar_sources_old[i].
get(), scalar_sources_new[i].
get());
650 for (
auto& target : target_exprs) {
651 auto target_it = old_to_new_target.find(target);
652 CHECK(target_it != old_to_new_target.end());
653 target = target_it->second;
663 , groupby_count_(rhs.groupby_count_)
665 , fields_(rhs.fields_)
666 , is_agg_(rhs.is_agg_)
673 , hint_applied_(
false)
674 , hints_(std::make_unique<
Hints>()) {
678 for (
auto const& kv : *rhs.
hints_) {
685 std::shared_ptr<const RelAlgNode> input) {
687 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
689 rebind_inputs.visit(target_expr.get());
692 rebind_inputs.visit(func_input.get());
697 int32_t literal_args = 0;
699 const auto rex_literal =
dynamic_cast<const RexLiteral*
>(arg.get());
709 , function_name_(rhs.function_name_)
710 , fields_(rhs.fields_)
711 , col_inputs_(rhs.col_inputs_)
714 std::unordered_map<const Rex*, const Rex*> old_to_new_input;
720 auto target_it = old_to_new_input.find(target);
721 CHECK(target_it != old_to_new_input.end());
722 target = target_it->second;
728 struct hash<std::pair<const RelAlgNode*, int>> {
729 size_t operator()(
const std::pair<const RelAlgNode*, int>& input_col)
const {
730 auto ptr_val =
reinterpret_cast<const int64_t*
>(&input_col.first);
731 auto h =
static_cast<size_t>(*ptr_val);
732 boost::hash_combine(h, input_col.second);
741 const size_t which_col) {
742 std::set<std::pair<const RelAlgNode*, int>> work_set;
744 auto curr_col = which_col;
746 work_set.insert(std::make_pair(walker, curr_col));
747 if (dynamic_cast<const RelScan*>(walker) || dynamic_cast<const RelJoin*>(walker)) {
750 CHECK_EQ(
size_t(1), walker->inputCount());
751 auto only_source = walker->getInput(0);
752 if (
auto project = dynamic_cast<const RelProject*>(walker)) {
753 if (
auto input = dynamic_cast<const RexInput*>(project->getProjectAt(curr_col))) {
754 const auto join_source =
dynamic_cast<const RelJoin*
>(only_source);
756 CHECK_EQ(
size_t(2), join_source->inputCount());
757 auto lhs = join_source->getInput(0);
758 CHECK((input->getIndex() < lhs->size() && lhs == input->getSourceNode()) ||
759 join_source->getInput(1) == input->getSourceNode());
761 CHECK_EQ(input->getSourceNode(), only_source);
763 curr_col = input->getIndex();
767 }
else if (
auto aggregate = dynamic_cast<const RelAggregate*>(walker)) {
768 if (curr_col >= aggregate->getGroupByCount()) {
772 walker = only_source;
784 for (
size_t i = 0, e =
collation_.size(); i < e; ++i) {
787 if (this_sort_key.getSortDir() != that_sort_key.getSortDir()) {
790 if (this_sort_key.getNullsPosition() != that_sort_key.getNullsPosition()) {
793 auto this_equiv_keys =
get_equiv_cols(
this, this_sort_key.getField());
794 auto that_equiv_keys =
get_equiv_cols(&that, that_sort_key.getField());
795 std::vector<std::pair<const RelAlgNode*, int>> intersect;
796 std::set_intersection(this_equiv_keys.begin(),
797 this_equiv_keys.end(),
798 that_equiv_keys.begin(),
799 that_equiv_keys.end(),
800 std::back_inserter(intersect));
801 if (intersect.empty()) {
811 :
RelAlgNode(std::move(inputs)), is_all_(is_all) {
814 "The DEPRECATED enable-union option is set to off. Please remove this option as "
815 "it may be disabled in the future.");
824 return inputs_.front()->size();
840 if (
auto const* input = dynamic_cast<RelCompound const*>(
inputs_[0].
get())) {
841 return input->getFieldName(i);
842 }
else if (
auto const* input = dynamic_cast<RelProject const*>(
inputs_[0].
get())) {
843 return input->getFieldName(i);
844 }
else if (
auto const* input = dynamic_cast<RelLogicalUnion const*>(
inputs_[0].
get())) {
845 return input->getFieldName(i);
846 }
else if (
auto const* input = dynamic_cast<RelAggregate const*>(
inputs_[0].
get())) {
847 return input->getFieldName(i);
848 }
else if (
auto const* input = dynamic_cast<RelScan const*>(
inputs_[0].
get())) {
849 return input->getFieldName(i);
850 }
else if (
auto const* input =
851 dynamic_cast<RelTableFunction const*>(
inputs_[0].
get())) {
852 return input->getFieldName(i);
859 std::vector<TargetMetaInfo>
const& tmis0 =
inputs_[0]->getOutputMetainfo();
860 for (
size_t i = 1; i <
inputs_.size(); ++i) {
861 std::vector<TargetMetaInfo>
const& tmisi =
inputs_[i]->getOutputMetainfo();
862 if (tmis0.size() != tmisi.size()) {
863 LOG(
INFO) <<
"tmis0.size()=" << tmis0.size() <<
" != " << tmisi.size()
864 <<
"=tmisi.size() for i=" << i;
865 throw std::runtime_error(
"Subqueries of a UNION must have matching data types.");
867 for (
size_t j = 0; j < tmis0.size(); ++j) {
868 if (tmis0[j].get_type_info() != tmisi[j].get_type_info()) {
871 LOG(
INFO) <<
"Types do not match for UNION:\n tmis0[" << j
872 <<
"].get_type_info().to_string() = " << ti0.
to_string() <<
"\n tmis"
874 <<
"].get_type_info().to_string() = " << ti1.
to_string();
877 throw std::runtime_error(
878 "Subqueries of a UNION must have the exact same data types.");
887 size_t input_idx)
const {
888 if (
auto const* rex_input_ptr = dynamic_cast<RexInput const*>(rex_scalar)) {
891 scalar_exprs_.emplace_back(std::make_shared<RexInput const>(std::move(rex_input)));
899 unsigned node_id(
const rapidjson::Value& ra_node) noexcept {
900 const auto&
id =
field(ra_node,
"id");
905 rapidjson::StringBuffer buffer;
906 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
908 return buffer.GetString();
916 const rapidjson::Value& expr) noexcept {
917 const auto& input =
field(expr,
"input");
922 CHECK(expr.IsObject());
923 const auto& literal =
field(expr,
"literal");
929 const auto type_precision =
json_i64(
field(expr,
"type_precision"));
930 if (literal.IsNull()) {
931 return std::unique_ptr<RexLiteral>(
new RexLiteral(target_type));
942 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_i64(literal),
950 if (literal.IsDouble()) {
951 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_double(literal),
958 }
else if (literal.IsInt64()) {
959 return std::make_unique<RexLiteral>(
static_cast<double>(literal.GetInt64()),
967 }
else if (literal.IsUint64()) {
968 return std::make_unique<RexLiteral>(
static_cast<double>(literal.GetUint64()),
976 UNREACHABLE() <<
"Unhandled type: " << literal.GetType();
979 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_str(literal),
987 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_bool(literal),
995 return std::unique_ptr<RexLiteral>(
new RexLiteral(target_type));
1003 std::unique_ptr<const RexScalar>
parse_scalar_expr(
const rapidjson::Value& expr,
1008 if (type_obj.IsArray()) {
1011 CHECK(type_obj.IsObject() && type_obj.MemberCount() >= 2)
1015 const auto precision_it = type_obj.FindMember(
"precision");
1016 const int precision =
1017 precision_it != type_obj.MemberEnd() ?
json_i64(precision_it->value) : 0;
1018 const auto scale_it = type_obj.FindMember(
"scale");
1019 const int scale = scale_it != type_obj.MemberEnd() ?
json_i64(scale_it->value) : 0;
1027 const rapidjson::Value& arr,
1030 std::vector<std::unique_ptr<const RexScalar>> exprs;
1031 for (
auto it = arr.Begin(); it != arr.End(); ++it) {
1038 if (name ==
"ROW_NUMBER") {
1041 if (name ==
"RANK") {
1044 if (name ==
"DENSE_RANK") {
1047 if (name ==
"PERCENT_RANK") {
1050 if (name ==
"CUME_DIST") {
1053 if (name ==
"NTILE") {
1056 if (name ==
"LAG") {
1059 if (name ==
"LEAD") {
1062 if (name ==
"FIRST_VALUE") {
1065 if (name ==
"LAST_VALUE") {
1068 if (name ==
"AVG") {
1071 if (name ==
"MIN") {
1074 if (name ==
"MAX") {
1077 if (name ==
"SUM") {
1080 if (name ==
"COUNT") {
1083 if (name ==
"$SUM0") {
1086 throw std::runtime_error(
"Unsupported window function: " + name);
1090 const rapidjson::Value& arr,
1093 std::vector<std::unique_ptr<const RexScalar>> exprs;
1094 for (
auto it = arr.Begin(); it != arr.End(); ++it) {
1101 return json_str(
field(collation,
"direction")) == std::string(
"DESCENDING")
1107 return json_str(
field(collation,
"nulls")) == std::string(
"FIRST")
1115 std::vector<SortField> collation;
1116 size_t field_idx = 0;
1117 for (
auto it = arr.Begin(); it != arr.End(); ++it, ++field_idx) {
1120 collation.emplace_back(field_idx, sort_dir, null_pos);
1126 const rapidjson::Value& window_bound_obj,
1129 CHECK(window_bound_obj.IsObject());
1132 window_bound.preceding =
json_bool(
field(window_bound_obj,
"preceding"));
1133 window_bound.following =
json_bool(
field(window_bound_obj,
"following"));
1134 window_bound.is_current_row =
json_bool(
field(window_bound_obj,
"is_current_row"));
1135 const auto& offset_field =
field(window_bound_obj,
"offset");
1136 if (offset_field.IsObject()) {
1139 CHECK(offset_field.IsNull());
1141 window_bound.order_key =
json_i64(
field(window_bound_obj,
"order_key"));
1142 return window_bound;
1148 const auto& operands =
field(expr,
"operands");
1149 CHECK(operands.IsArray());
1150 CHECK_GE(operands.Size(), unsigned(0));
1151 const auto& subquery_ast =
field(expr,
"subquery");
1154 auto subquery = std::make_shared<RexSubQuery>(subquery_dag->getRootNodeShPtr());
1156 return subquery->deepCopy();
1163 const bool is_quantifier =
1164 op_name == std::string(
"PG_ANY") || op_name == std::string(
"PG_ALL");
1166 const auto& operators_json_arr =
field(expr,
"operands");
1167 CHECK(operators_json_arr.IsArray());
1169 const auto type_it = expr.FindMember(
"type");
1170 CHECK(type_it != expr.MemberEnd());
1172 if (op ==
kIN && expr.HasMember(
"subquery")) {
1174 operands.emplace_back(std::move(subquery));
1176 if (expr.FindMember(
"partition_keys") != expr.MemberEnd()) {
1177 const auto& partition_keys_arr =
field(expr,
"partition_keys");
1179 const auto& order_keys_arr =
field(expr,
"order_keys");
1188 ti.set_notnull(
false);
1189 return std::make_unique<RexWindowFunctionOperator>(kind,
1199 return std::unique_ptr<RexOperator>(op ==
kFUNCTION
1204 std::unique_ptr<RexCase>
parse_case(
const rapidjson::Value& expr,
1207 const auto& operands =
field(expr,
"operands");
1208 CHECK(operands.IsArray());
1209 CHECK_GE(operands.Size(), unsigned(2));
1210 std::unique_ptr<const RexScalar> else_expr;
1212 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
1214 for (
auto operands_it = operands.Begin(); operands_it != operands.End();) {
1216 if (operands_it == operands.End()) {
1217 else_expr = std::move(when_expr);
1221 expr_pair_list.emplace_back(std::move(when_expr), std::move(then_expr));
1223 return std::unique_ptr<RexCase>(
new RexCase(expr_pair_list, else_expr));
1227 const rapidjson::Value& json_str_arr) noexcept {
1228 CHECK(json_str_arr.IsArray());
1229 std::vector<std::string> fields;
1230 for (
auto json_str_arr_it = json_str_arr.Begin(); json_str_arr_it != json_str_arr.End();
1231 ++json_str_arr_it) {
1232 CHECK(json_str_arr_it->IsString());
1233 fields.emplace_back(json_str_arr_it->GetString());
1239 const rapidjson::Value& json_idx_arr) noexcept {
1240 CHECK(json_idx_arr.IsArray());
1241 std::vector<size_t> indices;
1242 for (
auto json_idx_arr_it = json_idx_arr.Begin(); json_idx_arr_it != json_idx_arr.End();
1243 ++json_idx_arr_it) {
1244 CHECK(json_idx_arr_it->IsInt());
1245 CHECK_GE(json_idx_arr_it->GetInt(), 0);
1246 indices.emplace_back(json_idx_arr_it->GetInt());
1253 if (agg_str ==
"APPROX_QUANTILE") {
1254 LOG(
INFO) <<
"APPROX_QUANTILE is deprecated. Please use APPROX_PERCENTILE instead.";
1264 return std::unique_ptr<const RexAgg>(
new RexAgg(agg, distinct, agg_ti, operands));
1270 CHECK(expr.IsObject());
1271 if (expr.IsObject() && expr.HasMember(
"input")) {
1274 if (expr.IsObject() && expr.HasMember(
"literal")) {
1275 return std::unique_ptr<const RexScalar>(
parse_literal(expr));
1277 if (expr.IsObject() && expr.HasMember(
"op")) {
1279 if (op_str == std::string(
"CASE")) {
1280 return std::unique_ptr<const RexScalar>(
parse_case(expr, cat, root_dag));
1282 if (op_str == std::string(
"$SCALAR_QUERY")) {
1283 return std::unique_ptr<const RexScalar>(
parse_subquery(expr, cat, root_dag));
1285 return std::unique_ptr<const RexScalar>(
parse_operator(expr, cat, root_dag));
1292 if (join_type_name ==
"inner") {
1295 if (join_type_name ==
"left") {
1298 if (join_type_name ==
"semi") {
1301 if (join_type_name ==
"anti") {
1312 std::vector<std::unique_ptr<const RexScalar>> disambiguated_operands;
1313 for (
size_t i = 0; i < rex_operator->size(); ++i) {
1314 auto operand = rex_operator->getOperand(i);
1315 if (dynamic_cast<const RexSubQuery*>(operand)) {
1316 disambiguated_operands.emplace_back(rex_operator->getOperandAndRelease(i));
1321 const auto rex_window_function_operator =
1323 if (rex_window_function_operator) {
1324 const auto& partition_keys = rex_window_function_operator->
getPartitionKeys();
1325 std::vector<std::unique_ptr<const RexScalar>> disambiguated_partition_keys;
1326 for (
const auto& partition_key : partition_keys) {
1327 disambiguated_partition_keys.emplace_back(
1330 std::vector<std::unique_ptr<const RexScalar>> disambiguated_order_keys;
1331 const auto& order_keys = rex_window_function_operator->getOrderKeys();
1332 for (
const auto& order_key : order_keys) {
1333 disambiguated_order_keys.emplace_back(
disambiguate_rex(order_key.get(), ra_output));
1335 return rex_window_function_operator->disambiguatedOperands(
1336 disambiguated_operands,
1337 disambiguated_partition_keys,
1338 disambiguated_order_keys,
1339 rex_window_function_operator->getCollation());
1341 return rex_operator->getDisambiguated(disambiguated_operands);
1347 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
1348 disambiguated_expr_pair_list;
1349 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
1352 disambiguated_expr_pair_list.emplace_back(std::move(disambiguated_when),
1353 std::move(disambiguated_then));
1355 std::unique_ptr<const RexScalar> disambiguated_else{
1357 return std::unique_ptr<const RexCase>(
1358 new RexCase(disambiguated_expr_pair_list, disambiguated_else));
1367 const auto rex_abstract_input =
dynamic_cast<const RexAbstractInput*
>(rex_scalar);
1368 if (rex_abstract_input) {
1369 CHECK_LT(static_cast<size_t>(rex_abstract_input->getIndex()), ra_output.size());
1370 return std::unique_ptr<const RexInput>(
1371 new RexInput(ra_output[rex_abstract_input->getIndex()]));
1373 const auto rex_operator =
dynamic_cast<const RexOperator*
>(rex_scalar);
1377 const auto rex_case =
dynamic_cast<const RexCase*
>(rex_scalar);
1381 if (
auto const rex_literal = dynamic_cast<const RexLiteral*>(rex_scalar)) {
1382 return rex_literal->deepCopy();
1383 }
else if (
auto const rex_subquery = dynamic_cast<const RexSubQuery*>(rex_scalar)) {
1384 return rex_subquery->deepCopy();
1387 std::string(
typeid(*rex_scalar).name()));
1392 CHECK_EQ(
size_t(1), project_node->inputCount());
1393 std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
1394 for (
size_t i = 0; i < project_node->size(); ++i) {
1395 const auto projected_expr = project_node->getProjectAt(i);
1396 if (dynamic_cast<const RexSubQuery*>(projected_expr)) {
1397 disambiguated_exprs.emplace_back(project_node->getProjectAtAndRelease(i));
1402 project_node->setExpressions(disambiguated_exprs);
1407 std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
1408 for (
size_t i = 0; i < table_func_node->getTableFuncInputsSize(); ++i) {
1409 const auto target_expr = table_func_node->getTableFuncInputAt(i);
1410 if (dynamic_cast<const RexSubQuery*>(target_expr)) {
1411 disambiguated_exprs.emplace_back(table_func_node->getTableFuncInputAtAndRelease(i));
1416 table_func_node->setTableFuncInputs(disambiguated_exprs);
1419 void bind_inputs(
const std::vector<std::shared_ptr<RelAlgNode>>& nodes) noexcept {
1420 for (
auto ra_node : nodes) {
1421 const auto filter_node = std::dynamic_pointer_cast<
RelFilter>(ra_node);
1423 CHECK_EQ(
size_t(1), filter_node->inputCount());
1425 filter_node->getCondition(),
get_node_output(filter_node->getInput(0)));
1426 filter_node->setCondition(disambiguated_condition);
1429 const auto join_node = std::dynamic_pointer_cast<
RelJoin>(ra_node);
1431 CHECK_EQ(
size_t(2), join_node->inputCount());
1432 auto disambiguated_condition =
1434 join_node->setCondition(disambiguated_condition);
1437 const auto project_node = std::dynamic_pointer_cast<
RelProject>(ra_node);
1443 const auto table_func_node = std::dynamic_pointer_cast<
RelTableFunction>(ra_node);
1444 if (table_func_node) {
1450 input.reserve(table_func_node->inputCount());
1451 for (
size_t i = 0; i < table_func_node->inputCount(); i++) {
1453 input.insert(input.end(), node_output.begin(), node_output.end());
1466 for (
auto node : nodes) {
1467 Hints* hint_delivered =
nullptr;
1468 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
1470 if (agg_node->hasDeliveredHint()) {
1474 const auto project_node = std::dynamic_pointer_cast<
RelProject>(node);
1476 if (project_node->hasDeliveredHint()) {
1480 const auto compound_node = std::dynamic_pointer_cast<
RelCompound>(node);
1481 if (compound_node) {
1482 if (compound_node->hasDeliveredHint()) {
1486 if (hint_delivered && !hint_delivered->empty()) {
1487 rel_alg_dag.registerQueryHints(node, hint_delivered, global_query_hint);
1490 rel_alg_dag.setGlobalQueryHints(global_query_hint);
1501 nodes.rbegin(), nodes.rend(), [](
const std::shared_ptr<RelAlgNode>& node) {
1502 auto node_hash = node->toHash();
1503 CHECK_NE(node_hash, static_cast<size_t>(0));
1507 void mark_nops(
const std::vector<std::shared_ptr<RelAlgNode>>& nodes) noexcept {
1508 for (
auto node : nodes) {
1509 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
1510 if (!agg_node || agg_node->getAggExprsCount()) {
1513 CHECK_EQ(
size_t(1), node->inputCount());
1514 const auto agg_input_node =
dynamic_cast<const RelAggregate*
>(node->getInput(0));
1515 if (agg_input_node && !agg_input_node->getAggExprsCount() &&
1516 agg_node->getGroupByCount() == agg_input_node->getGroupByCount()) {
1526 const std::vector<const Rex*>& target_exprs) noexcept {
1527 std::vector<const Rex*>
result;
1528 for (
size_t i = 0; i < simple_project->size(); ++i) {
1529 const auto input_rex =
dynamic_cast<const RexInput*
>(simple_project->getProjectAt(i));
1531 CHECK_LT(static_cast<size_t>(input_rex->getIndex()), target_exprs.size());
1532 result.push_back(target_exprs[input_rex->getIndex()]);
1546 const std::vector<std::unique_ptr<const RexScalar>>& scalar_sources)
1547 : node_to_keep_(node_to_keep), scalar_sources_(scalar_sources) {}
1551 if (input->getSourceNode() == node_to_keep_) {
1552 const auto index = input->getIndex();
1553 CHECK_LT(index, scalar_sources_.size());
1554 return visit(scalar_sources_[index].
get());
1556 return input->deepCopy();
1568 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
1569 const std::vector<size_t>& pattern,
1570 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
1571 query_hints) noexcept {
1572 CHECK_GE(pattern.size(), size_t(2));
1573 CHECK_LE(pattern.size(), size_t(4));
1575 std::unique_ptr<const RexScalar> filter_rex;
1576 std::vector<std::unique_ptr<const RexScalar>> scalar_sources;
1577 size_t groupby_count{0};
1578 std::vector<std::string> fields;
1579 std::vector<const RexAgg*> agg_exprs;
1580 std::vector<const Rex*> target_exprs;
1581 bool first_project{
true};
1585 std::shared_ptr<ModifyManipulationTarget> manipulation_target;
1586 size_t node_hash{0};
1588 bool hint_registered{
false};
1590 for (
const auto node_idx : pattern) {
1591 const auto ra_node = nodes[node_idx];
1592 auto registered_query_hint_map_it = query_hints.find(ra_node->toHash());
1593 if (registered_query_hint_map_it != query_hints.end()) {
1594 auto& registered_query_hint_map = registered_query_hint_map_it->second;
1595 auto registered_query_hint_it = registered_query_hint_map.find(ra_node->getId());
1596 if (registered_query_hint_it != registered_query_hint_map.end()) {
1597 hint_registered =
true;
1598 node_hash = registered_query_hint_map_it->first;
1599 node_id = registered_query_hint_it->first;
1600 registered_query_hint = registered_query_hint_it->second;
1603 const auto ra_filter = std::dynamic_pointer_cast<
RelFilter>(ra_node);
1606 filter_rex.reset(ra_filter->getAndReleaseCondition());
1608 last_node = ra_node.get();
1611 const auto ra_project = std::dynamic_pointer_cast<
RelProject>(ra_node);
1614 manipulation_target = ra_project;
1616 if (first_project) {
1617 CHECK_EQ(
size_t(1), ra_project->inputCount());
1621 const auto filter_input =
dynamic_cast<const RelFilter*
>(ra_project->getInput(0));
1623 CHECK_EQ(
size_t(1), filter_input->inputCount());
1627 scalar_sources = ra_project->getExpressionsAndRelease();
1628 for (
const auto& scalar_expr : scalar_sources) {
1629 target_exprs.push_back(scalar_expr.get());
1631 first_project =
false;
1633 if (ra_project->isSimple()) {
1638 std::vector<const Rex*>
result;
1639 RexInputReplacementVisitor visitor(last_node, scalar_sources);
1640 for (
size_t i = 0; i < ra_project->size(); ++i) {
1641 const auto rex = ra_project->getProjectAt(i);
1642 if (
auto rex_input = dynamic_cast<const RexInput*>(rex)) {
1643 const auto index = rex_input->getIndex();
1644 CHECK_LT(index, target_exprs.size());
1645 result.push_back(target_exprs[index]);
1647 scalar_sources.push_back(visitor.visit(rex));
1648 result.push_back(scalar_sources.back().get());
1654 last_node = ra_node.get();
1657 const auto ra_aggregate = std::dynamic_pointer_cast<
RelAggregate>(ra_node);
1660 fields = ra_aggregate->getFields();
1661 agg_exprs = ra_aggregate->getAggregatesAndRelease();
1662 groupby_count = ra_aggregate->getGroupByCount();
1663 decltype(target_exprs){}.swap(target_exprs);
1664 CHECK_LE(groupby_count, scalar_sources.size());
1665 for (
size_t group_idx = 0; group_idx < groupby_count; ++group_idx) {
1666 const auto rex_ref =
new RexRef(group_idx + 1);
1667 target_exprs.push_back(rex_ref);
1668 scalar_sources.emplace_back(rex_ref);
1670 for (
const auto rex_agg : agg_exprs) {
1671 target_exprs.push_back(rex_agg);
1673 last_node = ra_node.get();
1678 auto compound_node =
1679 std::make_shared<RelCompound>(filter_rex,
1686 manipulation_target->isUpdateViaSelect(),
1687 manipulation_target->isDeleteViaSelect(),
1688 manipulation_target->isVarlenUpdateRequired(),
1689 manipulation_target->getModifiedTableDescriptor(),
1690 manipulation_target->getTargetColumns());
1691 auto old_node = nodes[pattern.back()];
1692 nodes[pattern.back()] = compound_node;
1693 auto first_node = nodes[pattern.front()];
1694 CHECK_EQ(
size_t(1), first_node->inputCount());
1695 compound_node->addManagedInput(first_node->getAndOwnInput(0));
1696 if (hint_registered) {
1699 auto registered_query_hint_map_it = query_hints.find(node_hash);
1700 CHECK(registered_query_hint_map_it != query_hints.end());
1701 auto registered_query_hint_map = registered_query_hint_map_it->second;
1702 if (registered_query_hint_map.size() > 1) {
1703 registered_query_hint_map.erase(
node_id);
1705 CHECK_EQ(registered_query_hint_map.size(),
static_cast<size_t>(1));
1706 query_hints.erase(node_hash);
1708 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
1709 hint_map.emplace(compound_node->getId(), registered_query_hint);
1710 query_hints.emplace(compound_node->toHash(), hint_map);
1712 for (
size_t i = 0; i < pattern.size() - 1; ++i) {
1713 nodes[pattern[i]].reset();
1715 for (
auto node : nodes) {
1719 node->replaceInput(old_node, compound_node);
1723 class RANodeIterator :
public std::vector<std::shared_ptr<RelAlgNode>>::const_iterator {
1725 using Super = std::vector<ElementType>::const_iterator;
1732 : Super(nodes.begin()), owner_(nodes), nodeCount_([&nodes]() -> size_t {
1733 size_t non_zero_count = 0;
1734 for (
const auto& node : nodes) {
1742 explicit operator size_t() {
1743 return std::distance(owner_.begin(), *
static_cast<Super*
>(
this));
1746 RANodeIterator operator++() =
delete;
1749 Super& super = *
this;
1751 case AdvancingMode::DUChain: {
1752 size_t use_count = 0;
1753 Super only_use = owner_.end();
1754 for (
Super nodeIt = std::next(super); nodeIt != owner_.end(); ++nodeIt) {
1758 for (
size_t i = 0; i < (*nodeIt)->inputCount(); ++i) {
1759 if ((*super) == (*nodeIt)->getAndOwnInput(i)) {
1761 if (1 == use_count) {
1764 super = owner_.end();
1773 case AdvancingMode::InOrder:
1774 for (
size_t i = 0; i != owner_.size(); ++i) {
1775 if (!visited_.count(i)) {
1776 super = owner_.begin();
1777 std::advance(super, i);
1781 super = owner_.end();
1791 visited_.insert(
size_t(*
this));
1792 Super& super = *
this;
1808 const bool first_rex_is_input) {
1809 if (
auto agg_node = dynamic_cast<const RelAggregate*>(parent_node)) {
1810 if (index == 0 && agg_node->getGroupByCount() > 0) {
1816 return first_rex_is_input;
1819 return first_rex_is_input;
1844 return aggregate && next_result;
1852 const auto case_operator =
dynamic_cast<const RexCase*
>(rex);
1853 if (case_operator && case_operator->branchCount() == 1) {
1854 const auto then_window =
1869 const auto case_operator =
1871 const auto second_window =
1873 if (case_operator && second_window &&
1886 if (dynamic_cast<const RexWindowFunctionOperator*>(rex)) {
1891 const auto rex_cast =
dynamic_cast<const RexOperator*
>(rex);
1892 if (rex_cast && rex_cast->getOperator() ==
kCAST) {
1893 CHECK_EQ(rex_cast->size(), size_t(1));
1907 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
1908 const std::vector<const RelAlgNode*>& left_deep_joins,
1909 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
1911 enum class CoalesceState { Initial, Filter, FirstProject, Aggregate };
1912 std::vector<size_t> crt_pattern;
1913 CoalesceState crt_state{CoalesceState::Initial};
1915 auto reset_state = [&crt_pattern, &crt_state]() {
1916 crt_state = CoalesceState::Initial;
1917 std::vector<size_t>().
swap(crt_pattern);
1921 const auto ra_node = nodeIt != nodes.end() ? *nodeIt :
nullptr;
1922 switch (crt_state) {
1923 case CoalesceState::Initial: {
1924 if (std::dynamic_pointer_cast<const RelFilter>(ra_node) &&
1925 std::find(left_deep_joins.begin(), left_deep_joins.end(), ra_node.get()) ==
1926 left_deep_joins.end()) {
1927 crt_pattern.push_back(
size_t(nodeIt));
1928 crt_state = CoalesceState::Filter;
1929 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1930 }
else if (
auto project_node =
1931 std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1932 if (project_node->hasWindowFunctionExpr()) {
1933 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1935 crt_pattern.push_back(
size_t(nodeIt));
1936 crt_state = CoalesceState::FirstProject;
1937 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1940 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1944 case CoalesceState::Filter: {
1945 if (
auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1948 CHECK(!project_node->hasWindowFunctionExpr());
1949 crt_pattern.push_back(
size_t(nodeIt));
1950 crt_state = CoalesceState::FirstProject;
1951 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1957 case CoalesceState::FirstProject: {
1958 if (std::dynamic_pointer_cast<const RelAggregate>(ra_node)) {
1959 crt_pattern.push_back(
size_t(nodeIt));
1960 crt_state = CoalesceState::Aggregate;
1961 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1963 if (crt_pattern.size() >= 2) {
1970 case CoalesceState::Aggregate: {
1971 if (
auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1972 if (!project_node->hasWindowFunctionExpr()) {
1974 bool is_simple_project{
true};
1975 for (
size_t i = 0; i < project_node->size(); i++) {
1976 const auto scalar_rex = project_node->getProjectAt(i);
1978 if (
auto input_rex = dynamic_cast<const RexInput*>(scalar_rex)) {
1980 input_rex->getSourceNode(), input_rex->getIndex(),
true)) {
1981 is_simple_project =
false;
1986 CoalesceSecondaryProjectVisitor visitor;
1987 if (!visitor.visit(project_node->getProjectAt(i))) {
1988 is_simple_project =
false;
1992 if (is_simple_project) {
1993 crt_pattern.push_back(
size_t(nodeIt));
1994 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1998 CHECK_GE(crt_pattern.size(), size_t(2));
2007 if (crt_state == CoalesceState::FirstProject || crt_state == CoalesceState::Aggregate) {
2008 if (crt_pattern.size() >= 2) {
2011 CHECK(!crt_pattern.empty());
2018 std::unordered_map<size_t, const RexScalar*>& collected_window_func)
2019 : collected_window_func_(collected_window_func) {}
2025 collected_window_func_.emplace(rex_operator->toHash(), rex_operator);
2027 const size_t operand_count = rex_operator->size();
2028 for (
size_t i = 0; i < operand_count; ++i) {
2029 const auto operand = rex_operator->getOperand(i);
2033 collected_window_func_.emplace(operand->toHash(), operand);
2038 return defaultResult();
2047 collected_window_func_.emplace(rex_case->
toHash(), rex_case);
2051 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
2052 const auto when = rex_case->
getWhen(i);
2054 collected_window_func_.emplace(when->toHash(), when);
2058 const auto then = rex_case->
getThen(i);
2060 collected_window_func_.emplace(then->toHash(), then);
2066 auto else_expr = rex_case->
getElse();
2068 collected_window_func_.emplace(else_expr->toHash(), else_expr);
2073 return defaultResult();
2085 std::unordered_set<size_t>& collected_window_func_hash,
2086 std::vector<std::unique_ptr<const RexScalar>>& new_rex_input_for_window_func,
2087 std::unordered_map<size_t, size_t>& window_func_to_new_rex_input_idx_map,
2089 std::unordered_map<
size_t, std::unique_ptr<const RexInput>>&
2090 new_rex_input_from_child_node)
2091 : collected_window_func_hash_(collected_window_func_hash)
2092 , new_rex_input_for_window_func_(new_rex_input_for_window_func)
2093 , window_func_to_new_rex_input_idx_map_(window_func_to_new_rex_input_idx_map)
2094 , new_project_(new_project)
2095 , new_rex_input_from_child_node_(new_rex_input_from_child_node) {
2096 CHECK_EQ(collected_window_func_hash_.size(),
2097 window_func_to_new_rex_input_idx_map_.size());
2098 for (
auto hash : collected_window_func_hash_) {
2099 auto rex_it = window_func_to_new_rex_input_idx_map_.find(hash);
2100 CHECK(rex_it != window_func_to_new_rex_input_idx_map_.end());
2101 CHECK_LT(rex_it->second, new_rex_input_for_window_func_.size());
2103 CHECK(new_project_);
2108 if (rex_input->getSourceNode() != new_project_) {
2109 const auto cur_index = rex_input->getIndex();
2110 auto cur_source_node = rex_input->getSourceNode();
2111 std::string field_name =
"";
2112 if (
auto cur_project_node = dynamic_cast<const RelProject*>(cur_source_node)) {
2113 field_name = cur_project_node->getFieldName(cur_index);
2115 auto rex_input_hash = rex_input->toHash();
2116 auto rex_input_it = new_rex_input_from_child_node_.find(rex_input_hash);
2117 if (rex_input_it == new_rex_input_from_child_node_.end()) {
2118 auto new_rex_input =
2119 std::make_unique<RexInput>(new_project_, new_project_->size());
2120 new_project_->appendInput(field_name, rex_input->deepCopy());
2121 new_rex_input_from_child_node_.emplace(rex_input_hash, new_rex_input->deepCopy());
2122 return new_rex_input;
2124 return rex_input_it->second->deepCopy();
2127 return rex_input->deepCopy();
2132 auto new_rex_idx = is_collected_window_function(rex_operator->toHash());
2134 return get_new_rex_input(*new_rex_idx);
2137 const auto rex_window_function_operator =
2139 if (rex_window_function_operator) {
2141 return visitWindowFunctionOperator(rex_window_function_operator);
2144 const size_t operand_count = rex_operator->size();
2145 std::vector<RetType> new_opnds;
2146 for (
size_t i = 0; i < operand_count; ++i) {
2147 const auto operand = rex_operator->getOperand(i);
2148 auto new_rex_idx_for_operand = is_collected_window_function(operand->toHash());
2149 if (new_rex_idx_for_operand) {
2150 new_opnds.push_back(get_new_rex_input(*new_rex_idx_for_operand));
2152 new_opnds.emplace_back(visit(rex_operator->getOperand(i)));
2155 return rex_operator->getDisambiguated(new_opnds);
2159 auto new_rex_idx = is_collected_window_function(rex_case->
toHash());
2161 return get_new_rex_input(*new_rex_idx);
2164 std::vector<std::pair<RetType, RetType>> new_pair_list;
2165 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
2166 auto when_operand = rex_case->
getWhen(i);
2167 auto new_rex_idx_for_when_operand =
2168 is_collected_window_function(when_operand->toHash());
2170 auto then_operand = rex_case->
getThen(i);
2171 auto new_rex_idx_for_then_operand =
2172 is_collected_window_function(then_operand->toHash());
2174 new_pair_list.emplace_back(
2175 new_rex_idx_for_when_operand ? get_new_rex_input(*new_rex_idx_for_when_operand)
2176 : visit(when_operand),
2177 new_rex_idx_for_then_operand ? get_new_rex_input(*new_rex_idx_for_then_operand)
2178 : visit(then_operand));
2180 auto new_rex_idx_for_else_operand =
2181 is_collected_window_function(rex_case->
getElse()->
toHash());
2182 auto new_else = new_rex_idx_for_else_operand
2183 ? get_new_rex_input(*new_rex_idx_for_else_operand)
2185 return std::make_unique<RexCase>(new_pair_list, new_else);
2190 auto rex_it = window_func_to_new_rex_input_idx_map_.find(rex_hash);
2191 if (rex_it != window_func_to_new_rex_input_idx_map_.end()) {
2192 return rex_it->second;
2194 return std::nullopt;
2199 CHECK_LT(rex_idx, new_rex_input_for_window_func_.size());
2200 auto& new_rex_input = new_rex_input_for_window_func_.at(rex_idx);
2201 CHECK(new_rex_input);
2202 auto copied_rex_input = copier_.visit(new_rex_input.get());
2203 return copied_rex_input;
2212 std::unordered_map<size_t, std::unique_ptr<const RexInput>>&
2218 std::shared_ptr<RelProject> prev_node,
2219 std::shared_ptr<RelProject> new_node,
2220 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2222 auto delivered_hints = prev_node->getDeliveredHints();
2223 bool needs_propagate_hints = !delivered_hints->empty();
2224 if (needs_propagate_hints) {
2225 for (
auto& kv : *delivered_hints) {
2226 new_node->addHint(kv.second);
2228 auto prev_it = query_hints.find(prev_node->toHash());
2230 CHECK(prev_it != query_hints.end());
2231 auto prev_hint_it = prev_it->second.find(prev_node->getId());
2232 CHECK(prev_hint_it != prev_it->second.end());
2233 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2234 hint_map.emplace(new_node->getId(), prev_hint_it->second);
2235 query_hints.emplace(new_node->toHash(), hint_map);
2262 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
2263 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2265 std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
2266 for (
auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
2267 const auto node = *node_itr;
2268 auto window_func_project_node = std::dynamic_pointer_cast<
RelProject>(node);
2269 if (!window_func_project_node) {
2273 const auto prev_node_itr = std::prev(node_itr);
2274 const auto prev_node = *prev_node_itr;
2278 std::unordered_map<size_t, const RexScalar*> collected_window_func;
2282 for (
size_t i = 0; i < window_func_project_node->size(); i++) {
2283 const auto scalar_rex = window_func_project_node->getProjectAt(i);
2288 collector.
visit(scalar_rex);
2291 if (!collected_window_func.empty()) {
2293 std::unordered_set<size_t> collected_window_func_hash;
2296 std::vector<std::unique_ptr<const RexScalar>> new_rex_input_for_window_func;
2298 std::vector<std::unique_ptr<const RexScalar>> new_scalar_expr_for_window_project;
2301 std::unordered_map<size_t, size_t> window_func_to_new_rex_input_idx_map;
2305 std::unordered_map<size_t, std::unique_ptr<const RexInput>>
2306 new_rex_input_from_child_node;
2309 std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
2310 std::vector<std::string> dummy_fields;
2311 std::vector<std::string> new_project_field_names;
2314 std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);
2317 node_list.insert(node_itr, new_project);
2321 std::for_each(collected_window_func.begin(),
2322 collected_window_func.end(),
2323 [&new_project_field_names,
2324 &collected_window_func_hash,
2325 &new_rex_input_for_window_func,
2326 &new_scalar_expr_for_window_project,
2329 &window_func_to_new_rex_input_idx_map](
const auto& kv) {
2332 collected_window_func_hash.insert(kv.first);
2336 const auto rex_idx = new_rex_input_for_window_func.size();
2337 window_func_to_new_rex_input_idx_map.emplace(kv.first, rex_idx);
2341 new_rex_input_for_window_func.emplace_back(
2342 std::make_unique<const RexInput>(new_project.get(), rex_idx));
2343 new_scalar_expr_for_window_project.push_back(
2344 std::move(copier.visit(kv.second)));
2345 new_project_field_names.emplace_back(
"");
2347 new_project->setExpressions(new_scalar_expr_for_window_project);
2348 new_project->setFields(std::move(new_project_field_names));
2350 auto window_func_scalar_exprs =
2351 window_func_project_node->getExpressionsAndRelease();
2353 new_rex_input_for_window_func,
2354 window_func_to_new_rex_input_idx_map,
2356 new_rex_input_from_child_node);
2358 for (
auto& scalar_expr : window_func_scalar_exprs) {
2361 auto new_parent_rex = replacer.
visit(scalar_expr.get());
2362 window_func_scalar_exprs[rex_idx] = std::move(new_parent_rex);
2366 window_func_project_node->setExpressions(window_func_scalar_exprs);
2367 window_func_project_node->replaceInput(prev_node, new_project);
2371 nodes.assign(node_list.begin(), node_list.end());
2386 result.insert(next_result.begin(), next_result.end());
2404 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
2405 const bool always_add_project_if_first_project_is_window_expr,
2406 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2408 std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
2409 size_t project_node_counter{0};
2410 for (
auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
2411 const auto node = *node_itr;
2413 auto window_func_project_node = std::dynamic_pointer_cast<
RelProject>(node);
2414 if (!window_func_project_node) {
2417 project_node_counter++;
2418 if (!window_func_project_node->hasWindowFunctionExpr()) {
2424 auto need_pushdown_generic_expr = [&window_func_project_node]() {
2425 for (
size_t i = 0; i < window_func_project_node->size(); ++i) {
2426 const auto projected_target = window_func_project_node->
getProjectAt(i);
2427 if (
auto window_expr =
2428 dynamic_cast<const RexWindowFunctionOperator*>(projected_target)) {
2429 for (
const auto& partition_key : window_expr->getPartitionKeys()) {
2430 auto partition_input =
dynamic_cast<const RexInput*
>(partition_key.get());
2431 if (!partition_input) {
2435 for (
const auto& order_key : window_expr->getOrderKeys()) {
2436 auto order_input =
dynamic_cast<const RexInput*
>(order_key.get());
2446 const auto prev_node_itr = std::prev(node_itr);
2447 const auto prev_node = *prev_node_itr;
2450 auto filter_node = std::dynamic_pointer_cast<
RelFilter>(prev_node);
2451 auto join_node = std::dynamic_pointer_cast<
RelJoin>(prev_node);
2453 auto scan_node = std::dynamic_pointer_cast<
RelScan>(prev_node);
2454 const bool has_multi_fragment_scan_input =
2456 (scan_node->getNumShards() > 0 || scan_node->getNumFragments() > 1));
2457 const bool needs_expr_pushdown = need_pushdown_generic_expr();
2482 if (!((always_add_project_if_first_project_is_window_expr &&
2483 project_node_counter == 1) ||
2484 filter_node || join_node || has_multi_fragment_scan_input ||
2485 needs_expr_pushdown)) {
2489 if (needs_expr_pushdown || join_node) {
2493 std::unordered_map<size_t, size_t> expr_offset_cache;
2494 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_new_project;
2495 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_window_project;
2496 std::vector<std::string> fields_for_window_project;
2497 std::vector<std::string> fields_for_new_project;
2500 std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
2501 std::vector<std::string> dummy_fields;
2503 std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);
2507 scalar_exprs_for_new_project,
2508 fields_for_new_project,
2510 for (
size_t i = 0; i < window_func_project_node->size(); ++i) {
2511 auto projected_target = window_func_project_node->getProjectAt(i);
2512 auto new_projection_target = visitor.visit(projected_target);
2513 scalar_exprs_for_window_project.emplace_back(
2514 std::move(new_projection_target.release()));
2516 new_project->setExpressions(scalar_exprs_for_new_project);
2517 new_project->setFields(std::move(fields_for_new_project));
2518 bool has_groupby =
false;
2519 auto aggregate = std::dynamic_pointer_cast<
RelAggregate>(prev_node);
2523 if (has_groupby && visitor.hasPartitionExpression()) {
2531 <<
"Query output overridden to row-wise format due to presence of a window "
2532 "function with partition expression and group-by expression.";
2533 new_project->forceRowwiseOutput();
2535 if (visitor.hasCaseExprAsWindowOperand()) {
2538 <<
"Query output overridden to row-wise format due to presence of a window "
2539 "function with a case statement as its operand.";
2540 new_project->forceRowwiseOutput();
2545 node_list.insert(node_itr, new_project);
2546 window_func_project_node->replaceInput(prev_node, new_project);
2547 window_func_project_node->setExpressions(scalar_exprs_for_window_project);
2552 for (
size_t i = 0; i < window_func_project_node->size(); i++) {
2554 input_collector.
visit(window_func_project_node->getProjectAt(i));
2555 inputs.insert(new_inputs.begin(), new_inputs.end());
2560 std::vector<RexInput> sorted_inputs(inputs.begin(), inputs.end());
2562 sorted_inputs.end(),
2563 [](
const auto&
a,
const auto& b) {
return a.getIndex() < b.getIndex(); });
2565 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs;
2566 std::vector<std::string> fields;
2567 std::unordered_map<unsigned, unsigned> old_index_to_new_index;
2568 for (
auto& input : sorted_inputs) {
2569 CHECK_EQ(input.getSourceNode(), prev_node.get());
2570 CHECK(old_index_to_new_index
2571 .insert(std::make_pair(input.getIndex(), scalar_exprs.size()))
2573 scalar_exprs.emplace_back(input.deepCopy());
2574 fields.emplace_back(
"");
2577 auto new_project = std::make_shared<RelProject>(scalar_exprs, fields, prev_node);
2579 node_list.insert(node_itr, new_project);
2580 window_func_project_node->replaceInput(
2581 prev_node, new_project, old_index_to_new_index);
2584 nodes.assign(node_list.begin(), node_list.end());
2589 const int64_t default_val) noexcept {
2590 const auto it = obj.FindMember(
field);
2591 if (it == obj.MemberEnd()) {
2596 CHECK_EQ(
unsigned(0), lit->getScale());
2597 CHECK_EQ(
unsigned(0), lit->getTargetScale());
2598 return lit->getVal<int64_t>();
2602 const auto& inputs_json =
field(node,
"inputs");
2603 CHECK(inputs_json.IsArray() && !inputs_json.Size());
2607 const rapidjson::Value& scan_ra) {
2608 const auto& table_json =
field(scan_ra,
"table");
2609 CHECK(table_json.IsArray());
2610 CHECK_EQ(
unsigned(2), table_json.Size());
2617 const auto& fields_json =
field(scan_ra,
"fieldNames");
2637 std::vector<std::shared_ptr<RelAlgNode>>
run(
const rapidjson::Value& rels,
2639 for (
auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
2640 const auto& crt_node = *rels_it;
2641 const auto id =
node_id(crt_node);
2643 CHECK(crt_node.IsObject());
2644 std::shared_ptr<RelAlgNode> ra_node =
nullptr;
2646 if (rel_op == std::string(
"EnumerableTableScan") ||
2647 rel_op == std::string(
"LogicalTableScan")) {
2649 }
else if (rel_op == std::string(
"LogicalProject")) {
2651 }
else if (rel_op == std::string(
"LogicalFilter")) {
2653 }
else if (rel_op == std::string(
"LogicalAggregate")) {
2655 }
else if (rel_op == std::string(
"LogicalJoin")) {
2657 }
else if (rel_op == std::string(
"LogicalSort")) {
2659 }
else if (rel_op == std::string(
"LogicalValues")) {
2661 }
else if (rel_op == std::string(
"LogicalTableModify")) {
2663 }
else if (rel_op == std::string(
"LogicalTableFunctionScan")) {
2665 }
else if (rel_op == std::string(
"LogicalUnion")) {
2670 nodes_.push_back(ra_node);
2673 return std::move(
nodes_);
2679 CHECK(scan_ra.IsObject());
2682 if (scan_ra.HasMember(
"hints")) {
2683 auto scan_node = std::make_shared<RelScan>(td, field_names);
2687 return std::make_shared<RelScan>(td, field_names);
2693 CHECK_EQ(
size_t(1), inputs.size());
2694 const auto& exprs_json =
field(proj_ra,
"exprs");
2695 CHECK(exprs_json.IsArray());
2696 std::vector<std::unique_ptr<const RexScalar>> exprs;
2697 for (
auto exprs_json_it = exprs_json.Begin(); exprs_json_it != exprs_json.End();
2701 const auto& fields =
field(proj_ra,
"fields");
2702 if (proj_ra.HasMember(
"hints")) {
2703 auto project_node = std::make_shared<RelProject>(
2706 return project_node;
2708 return std::make_shared<RelProject>(
2715 CHECK_EQ(
size_t(1), inputs.size());
2716 const auto id =
node_id(filter_ra);
2719 return std::make_shared<RelFilter>(condition, inputs.front());
2724 CHECK_EQ(
size_t(1), inputs.size());
2727 for (
size_t i = 0; i < group.size(); ++i) {
2730 if (agg_ra.HasMember(
"groups") || agg_ra.HasMember(
"indicator")) {
2733 const auto& aggs_json_arr =
field(agg_ra,
"aggs");
2734 CHECK(aggs_json_arr.IsArray());
2735 std::vector<std::unique_ptr<const RexAgg>> aggs;
2736 for (
auto aggs_json_arr_it = aggs_json_arr.Begin();
2737 aggs_json_arr_it != aggs_json_arr.End();
2738 ++aggs_json_arr_it) {
2741 if (agg_ra.HasMember(
"hints")) {
2743 std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
2747 return std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
2753 CHECK_EQ(
size_t(2), inputs.size());
2756 if (join_ra.HasMember(
"hints")) {
2758 std::make_shared<RelJoin>(inputs[0], inputs[1], filter_rex, join_type);
2762 return std::make_shared<RelJoin>(inputs[0], inputs[1], filter_rex, join_type);
2767 CHECK_EQ(
size_t(1), inputs.size());
2768 std::vector<SortField> collation;
2769 const auto& collation_arr =
field(sort_ra,
"collation");
2770 CHECK(collation_arr.IsArray());
2771 for (
auto collation_arr_it = collation_arr.Begin();
2772 collation_arr_it != collation_arr.End();
2773 ++collation_arr_it) {
2774 const size_t field_idx =
json_i64(
field(*collation_arr_it,
"field"));
2777 collation.emplace_back(field_idx, sort_dir, null_pos);
2781 auto ret = std::make_shared<RelSort>(
2782 collation, limit > 0 ? limit : 0, offset, inputs.front(), limit > 0);
2783 ret->setEmptyResult(limit == 0);
2787 std::shared_ptr<RelModify>
dispatchModify(
const rapidjson::Value& logical_modify_ra) {
2789 CHECK_EQ(
size_t(1), inputs.size());
2792 if (table_descriptor->isView) {
2793 throw std::runtime_error(
"UPDATE of a view is unsupported.");
2796 bool flattened =
json_bool(
field(logical_modify_ra,
"flattened"));
2797 std::string op =
json_str(
field(logical_modify_ra,
"operation"));
2800 if (op ==
"UPDATE") {
2801 const auto& update_columns =
field(logical_modify_ra,
"updateColumnList");
2802 CHECK(update_columns.IsArray());
2804 for (
auto column_arr_it = update_columns.Begin();
2805 column_arr_it != update_columns.End();
2807 target_column_list.push_back(column_arr_it->GetString());
2811 auto modify_node = std::make_shared<RelModify>(
2812 cat_, table_descriptor, flattened, op, target_column_list, inputs[0]);
2813 switch (modify_node->getOperation()) {
2815 modify_node->applyDeleteModificationsToInputNode();
2819 modify_node->applyUpdateModificationsToInputNode();
2823 throw std::runtime_error(
"Unsupported RelModify operation: " +
2831 const rapidjson::Value& table_func_ra,
2834 const auto& invocation =
field(table_func_ra,
"invocation");
2835 CHECK(invocation.IsObject());
2837 const auto& operands =
field(invocation,
"operands");
2838 CHECK(operands.IsArray());
2839 CHECK_GE(operands.Size(), unsigned(0));
2841 std::vector<const Rex*> col_inputs;
2842 std::vector<std::unique_ptr<const RexScalar>> table_func_inputs;
2843 std::vector<std::string> fields;
2845 for (
auto exprs_json_it = operands.Begin(); exprs_json_it != operands.End();
2847 const auto& expr_json = *exprs_json_it;
2848 CHECK(expr_json.IsObject());
2849 if (expr_json.HasMember(
"op")) {
2851 if (op_str ==
"CAST" && expr_json.HasMember(
"type")) {
2852 const auto& expr_type =
field(expr_json,
"type");
2853 CHECK(expr_type.IsObject());
2854 CHECK(expr_type.HasMember(
"type"));
2855 const auto& expr_type_name =
json_str(
field(expr_type,
"type"));
2856 if (expr_type_name ==
"CURSOR") {
2857 CHECK(expr_json.HasMember(
"operands"));
2858 const auto& expr_operands =
field(expr_json,
"operands");
2859 CHECK(expr_operands.IsArray());
2860 if (expr_operands.Size() != 1) {
2861 throw std::runtime_error(
2862 "Table functions currently only support one ResultSet input");
2864 auto pos =
field(expr_operands[0],
"input").GetInt();
2866 for (
size_t i = inputs[pos]->size(); i > 0; i--) {
2867 table_func_inputs.emplace_back(
2868 std::make_unique<RexAbstractInput>(col_inputs.size()));
2869 col_inputs.emplace_back(table_func_inputs.back().get());
2878 const auto& op_name =
field(invocation,
"op");
2879 CHECK(op_name.IsString());
2881 std::vector<std::unique_ptr<const RexScalar>> table_function_projected_outputs;
2882 const auto& row_types =
field(table_func_ra,
"rowType");
2883 CHECK(row_types.IsArray());
2884 CHECK_GE(row_types.Size(), unsigned(0));
2885 const auto& row_types_array = row_types.GetArray();
2886 for (
size_t i = 0; i < row_types_array.Size(); i++) {
2889 table_function_projected_outputs.emplace_back(std::make_unique<RexRef>(i));
2890 fields.emplace_back(
"");
2892 return std::make_shared<RelTableFunction>(op_name.GetString(),
2897 table_function_projected_outputs);
2901 const rapidjson::Value& logical_values_ra) {
2902 const auto& tuple_type_arr =
field(logical_values_ra,
"type");
2903 CHECK(tuple_type_arr.IsArray());
2904 std::vector<TargetMetaInfo> tuple_type;
2905 for (
auto tuple_type_arr_it = tuple_type_arr.Begin();
2906 tuple_type_arr_it != tuple_type_arr.End();
2907 ++tuple_type_arr_it) {
2908 const auto component_type =
parse_type(*tuple_type_arr_it);
2909 const auto component_name =
json_str(
field(*tuple_type_arr_it,
"name"));
2910 tuple_type.emplace_back(component_name, component_type);
2912 const auto& inputs_arr =
field(logical_values_ra,
"inputs");
2913 CHECK(inputs_arr.IsArray());
2914 const auto& tuples_arr =
field(logical_values_ra,
"tuples");
2915 CHECK(tuples_arr.IsArray());
2917 if (inputs_arr.Size()) {
2921 std::vector<RelLogicalValues::RowValues> values;
2922 if (tuples_arr.Size()) {
2923 for (
const auto& row : tuples_arr.GetArray()) {
2924 CHECK(row.IsArray());
2925 const auto values_json = row.GetArray();
2926 if (!values.empty()) {
2927 CHECK_EQ(values[0].size(), values_json.Size());
2930 for (
const auto& value : values_json) {
2931 CHECK(value.IsObject());
2932 CHECK(value.HasMember(
"literal"));
2938 return std::make_shared<RelLogicalValues>(tuple_type, values);
2942 const rapidjson::Value& logical_union_ra) {
2944 auto const& all_type_bool =
field(logical_union_ra,
"all");
2945 CHECK(all_type_bool.IsBool());
2946 return std::make_shared<RelLogicalUnion>(std::move(inputs), all_type_bool.GetBool());
2950 if (node.HasMember(
"inputs")) {
2953 for (
const auto& str_id : str_input_ids) {
2954 ra_inputs.push_back(
nodes_[std::stoi(str_id)]);
2958 return {
prev(node)};
2962 auto option = str.substr(0, pos);
2963 std::string delim =
"=";
2964 size_t delim_pos = option.find(delim);
2965 auto key = option.substr(0, delim_pos);
2966 auto val = option.substr(delim_pos + 1, option.length());
2967 str.erase(0, pos + delim.length() + 1);
2972 std::string white_space_delim =
" ";
2973 int l = hint_string.length();
2974 hint_string = hint_string.erase(0, 1).substr(0, l - 2);
2976 auto global_hint_checker = [&](
const std::string& input_hint_name) ->
HintIdentifier {
2977 bool global_hint =
false;
2978 std::string hint_name = input_hint_name;
2979 auto global_hint_identifier = hint_name.substr(0, 2);
2980 if (global_hint_identifier.compare(
"g_") == 0) {
2982 hint_name = hint_name.substr(2, hint_string.length());
2984 return {global_hint, hint_name};
2987 global_hint_checker(hint_string.substr(0, hint_string.find(white_space_delim)));
2989 if ((pos = hint_string.find(
"options:")) != std::string::npos) {
2991 std::vector<std::string> tokens;
2992 bool kv_list_op =
false;
2993 std::string raw_options = hint_string.substr(pos + 8, hint_string.length() - 2);
2994 if (raw_options.find(
'{') != std::string::npos) {
2997 CHECK(raw_options.find(
'[') != std::string::npos);
2999 auto t1 = raw_options.erase(0, 1);
3000 raw_options = t1.substr(0, t1.length() - 1);
3001 std::string op_delim =
", ";
3004 std::unordered_map<std::string, std::string> kv_options;
3005 while ((pos = raw_options.find(op_delim)) != std::string::npos) {
3007 kv_options.emplace(kv_pair.first, kv_pair.second);
3011 kv_options.emplace(kv_pair.first, kv_pair.second);
3012 return {hint_type, parsed_hint.global_hint,
false,
true, kv_options};
3014 std::vector<std::string> list_options;
3015 while ((pos = raw_options.find(op_delim)) != std::string::npos) {
3016 list_options.emplace_back(raw_options.substr(0, pos));
3017 raw_options.erase(0, pos + white_space_delim.length() + 1);
3020 list_options.emplace_back(raw_options.substr(0, pos));
3021 return {hint_type, parsed_hint.global_hint,
false,
false, list_options};
3025 return {hint_type, parsed_hint.global_hint,
true,
false};
3030 std::shared_ptr<RelAlgNode> node) {
3031 std::string hint_explained =
json_str(
field(json_node,
"hints"));
3033 std::string delim =
"|";
3034 std::vector<std::string> hint_list;
3035 while ((pos = hint_explained.find(delim)) != std::string::npos) {
3036 hint_list.emplace_back(hint_explained.substr(0, pos));
3037 hint_explained.erase(0, pos + delim.length());
3040 hint_list.emplace_back(hint_explained.substr(0, pos));
3042 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
3044 for (std::string& hint : hint_list) {
3046 agg_node->addHint(parsed_hint);
3049 const auto project_node = std::dynamic_pointer_cast<
RelProject>(node);
3051 for (std::string& hint : hint_list) {
3053 project_node->addHint(parsed_hint);
3056 const auto scan_node = std::dynamic_pointer_cast<
RelScan>(node);
3058 for (std::string& hint : hint_list) {
3060 scan_node->addHint(parsed_hint);
3063 const auto join_node = std::dynamic_pointer_cast<
RelJoin>(node);
3065 for (std::string& hint : hint_list) {
3067 join_node->addHint(parsed_hint);
3071 const auto compound_node = std::dynamic_pointer_cast<
RelCompound>(node);
3072 if (compound_node) {
3073 for (std::string& hint : hint_list) {
3075 compound_node->addHint(parsed_hint);
3080 std::shared_ptr<const RelAlgNode>
prev(
const rapidjson::Value& crt_node) {
3081 const auto id =
node_id(crt_node);
3088 std::vector<std::shared_ptr<RelAlgNode>>
nodes_;
3094 const std::string& query_ra,
3096 const bool optimize_dag) {
3097 rapidjson::Document query_ast;
3098 query_ast.Parse(query_ra.c_str());
3099 VLOG(2) <<
"Parsing query RA JSON: " << query_ra;
3100 if (query_ast.HasParseError()) {
3101 query_ast.GetParseError();
3102 LOG(
ERROR) <<
"Failed to parse RA tree from Calcite (offset "
3103 << query_ast.GetErrorOffset() <<
"):\n"
3104 << rapidjson::GetParseError_En(query_ast.GetParseError());
3105 VLOG(1) <<
"Failed to parse query RA: " << query_ra;
3106 throw std::runtime_error(
3107 "Failed to parse relational algebra tree. Possible query syntax error.");
3109 CHECK(query_ast.IsObject());
3112 return build(query_ast, cat,
nullptr, optimize_dag);
3117 const rapidjson::Value& query_ast,
3119 return build(query_ast, cat, &root_dag,
true);
3125 const bool optimize_dag) {
3126 const auto& rels =
field(query_ast,
"rels");
3127 CHECK(rels.IsArray());
3129 auto rel_alg_dag_ptr = std::make_unique<RelAlgDag>();
3130 auto& rel_alg_dag = *rel_alg_dag_ptr;
3131 auto& nodes =
getNodes(rel_alg_dag);
3138 CHECK(!nodes.empty());
3147 return rel_alg_dag_ptr;
3157 <<
static_cast<int>(build_state);
3159 auto& nodes =
getNodes(rel_alg_dag);
3170 std::vector<const RelAlgNode*> filtered_left_deep_joins;
3171 std::vector<const RelAlgNode*> left_deep_joins;
3172 for (
const auto& node : nodes) {
3176 if (left_deep_join_root) {
3177 left_deep_joins.push_back(left_deep_join_root.get());
3178 if (std::dynamic_pointer_cast<const RelFilter>(left_deep_join_root)) {
3179 filtered_left_deep_joins.push_back(left_deep_join_root.get());
3183 if (filtered_left_deep_joins.empty()) {
3194 CHECK(nodes.back().use_count() == 1);
3201 for (
auto const& node :
nodes_) {
3203 callback(node.get());
3209 for (
auto& node :
nodes_) {
3211 node->resetQueryExecutionState();
3219 for (
size_t i = 0; i < ra->
inputCount(); ++i) {
3226 return cat(::
typeName(
this),
"(", ra_->toString(config),
")");
3231 hash_ =
typeid(RexSubQuery).hash_code();
3232 boost::hash_combine(*hash_, ra_->toHash());
3238 const auto scan_node =
dynamic_cast<const RelScan*
>(
node_);
3241 auto table_name = scan_node->getTableDescriptor()->tableName;
3267 ret += expr->toString(config) +
" ";
3269 ret +=
", agg_exps=";
3271 ret += expr->toString(config) +
" ";
3273 ret +=
", scalar_sources=";
3275 ret += expr->toString(config) +
" ";
3293 if (
auto rex_scalar = dynamic_cast<const RexScalar*>(target_expr)) {
3294 boost::hash_combine(*
hash_, rex_scalar->toHash());
3298 boost::hash_combine(*
hash_, agg_expr->toHash());
3301 boost::hash_combine(*
hash_, scalar_source->toHash());
std::vector< std::shared_ptr< const RexScalar > > scalar_exprs_
DEVICE auto upper_bound(ARGS &&...args)
const size_t getGroupByCount() const
SQLTypes to_sql_type(const std::string &type_name)
std::optional< size_t > is_collected_window_function(size_t rex_hash) const
NullSortedPosition parse_nulls_position(const rapidjson::Value &collation)
bool is_agg(const Analyzer::Expr *expr)
std::unique_ptr< const RexScalar > condition_
std::unique_ptr< const RexOperator > disambiguate_operator(const RexOperator *rex_operator, const RANodeOutput &ra_output) noexcept
std::vector< ElementType > Container
const RexScalar * getThen(const size_t idx) const
std::shared_ptr< RelAggregate > dispatchAggregate(const rapidjson::Value &agg_ra)
std::shared_ptr< RelFilter > dispatchFilter(const rapidjson::Value &filter_ra, RelAlgDag &root_dag)
std::shared_ptr< RelAlgNode > ElementType
const Catalog_Namespace::Catalog & cat_
std::unique_ptr< RexOperator > parse_operator(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
void mark_nops(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::unique_ptr< RexSubQuery > deepCopy() const
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
static std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > & getQueryHints(RelAlgDag &rel_alg_dag)
std::vector< std::unique_ptr< const RexScalar > > table_func_inputs_
std::optional< size_t > getOffsetForPushedDownExpr(WindowExprType type, size_t expr_offset) const
RexWindowFuncReplacementVisitor(std::unordered_set< size_t > &collected_window_func_hash, std::vector< std::unique_ptr< const RexScalar >> &new_rex_input_for_window_func, std::unordered_map< size_t, size_t > &window_func_to_new_rex_input_idx_map, RelProject *new_project, std::unordered_map< size_t, std::unique_ptr< const RexInput >> &new_rex_input_from_child_node)
void hoist_filter_cond_to_cross_join(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
class for a per-database catalog. also includes metadata for the current database and the current use...
std::vector< std::unique_ptr< const RexScalar > > & scalar_exprs_for_new_project_
void addHint(const ExplainedQueryHint &hint_explained)
std::shared_ptr< const RelAlgNode > get_left_deep_join_root(const std::shared_ptr< RelAlgNode > &node)
const ElementType & operator*()
void sink_projected_boolean_expr_to_join(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
bool input_can_be_coalesced(const RelAlgNode *parent_node, const size_t index, const bool first_rex_is_input)
bool is_window_function_avg(const RexScalar *rex)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
void eliminate_identical_copy(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
RetType visitInput(const RexInput *rex_input) const final
std::vector< RexInput > RANodeOutput
std::unique_ptr< const RexCase > disambiguate_case(const RexCase *rex_case, const RANodeOutput &ra_output)
const RexScalar * getElse() const
RelCompound(std::unique_ptr< const RexScalar > &filter_expr, const std::vector< const Rex * > &target_exprs, const size_t groupby_count, const std::vector< const RexAgg * > &agg_exprs, const std::vector< std::string > &fields, std::vector< std::unique_ptr< const RexScalar >> &scalar_sources, const bool is_agg, bool update_disguised_as_select=false, bool delete_disguised_as_select=false, bool varlen_update_required=false, TableDescriptor const *manipulation_target_table=nullptr, ColumnNameList target_columns=ColumnNameList())
static thread_local unsigned crt_id_
std::unique_ptr< const RexScalar > visitOperator(const RexOperator *rex_operator) const override
SqlWindowFunctionKind parse_window_function_kind(const std::string &name)
RexDeepCopyVisitor deep_copier_
std::shared_ptr< RelScan > dispatchTableScan(const rapidjson::Value &scan_ra)
std::pair< std::shared_ptr< RelLeftDeepInnerJoin >, std::shared_ptr< const RelAlgNode > > create_left_deep_join(const std::shared_ptr< RelAlgNode > &left_deep_join_root)
RexScalar const * copyAndRedirectSource(RexScalar const *, size_t input_idx) const
const RelAlgNode * node_to_keep_
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::unique_ptr< const RexSubQuery > parse_subquery(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
SQLAgg to_agg_kind(const std::string &agg_name)
std::shared_ptr< RelLogicalUnion > dispatchUnion(const rapidjson::Value &logical_union_ra)
std::vector< std::string > TargetColumnList
void advance(AdvancingMode mode)
const SQLTypeInfo & getType() const
std::unique_ptr< const RexScalar > get_new_rex_input(size_t rex_idx) const
Hints * getDeliveredHints()
std::shared_ptr< RelProject > dispatchProject(const rapidjson::Value &proj_ra, RelAlgDag &root_dag)
const bool json_bool(const rapidjson::Value &obj) noexcept
const RexScalar * getOperand(const size_t idx) const
std::vector< std::unique_ptr< const RexScalar > > parse_window_order_exprs(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
std::vector< const Rex * > col_inputs_
std::string json_node_to_string(const rapidjson::Value &node) noexcept
bool hasEquivCollationOf(const RelSort &that) const
JoinType to_join_type(const std::string &join_type_name)
void resetQueryExecutionState()
std::vector< SortField > parse_window_order_collation(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
const std::string json_str(const rapidjson::Value &obj) noexcept
std::vector< std::shared_ptr< RelAlgNode > > nodes_
void handle_query_hint(const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDag &rel_alg_dag) noexcept
DEVICE void sort(ARGS &&...args)
std::unordered_map< size_t, size_t > & expr_offset_cache_
std::optional< size_t > getIdInPlanTree() const
std::vector< std::string > fields_
void pushDownExpressionInWindowFunction(const RexWindowFunctionOperator *window_expr) const
void addHint(const ExplainedQueryHint &hint_explained)
std::unique_ptr< const RexScalar > visitCase(const RexCase *rex_case) const override
const RexScalar * getWhen(const size_t idx) const
std::vector< size_t > indices_from_json_array(const rapidjson::Value &json_idx_arr) noexcept
void appendInput(std::string new_field_name, std::unique_ptr< const RexScalar > new_input)
void propagate_hints_to_new_project(std::shared_ptr< RelProject > prev_node, std::shared_ptr< RelProject > new_node, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
bool isRenamedInput(const RelAlgNode *node, const size_t index, const std::string &new_name)
RexDeepCopyVisitor copier_
size_t pushDownExpressionImpl(const RexScalar *expr) const
std::unique_ptr< const RexScalar > defaultResult() const override
void addHint(const ExplainedQueryHint &hint_explained)
std::unique_ptr< const RexAgg > parse_aggregate_expr(const rapidjson::Value &expr)
std::unordered_map< size_t, const RexScalar * > & collected_window_func_
void checkForMatchingMetaInfoTypes() const
std::unique_ptr< const RexScalar > parse_scalar_expr(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
std::vector< std::unique_ptr< const RexScalar > > scalar_sources_
std::unique_ptr< RexAbstractInput > parse_abstract_input(const rapidjson::Value &expr) noexcept
static std::vector< std::shared_ptr< RexSubQuery > > & getSubqueries(RelAlgDag &rel_alg_dag)
std::unique_ptr< const RexScalar > disambiguate_rex(const RexScalar *, const RANodeOutput &)
std::unique_ptr< const RexScalar > visitLiteral(const RexLiteral *rex_literal) const override
const ElementType * operator->()
void add_window_function_pre_project(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const bool always_add_project_if_first_project_is_window_expr, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
const std::string getFieldName(const size_t i) const
std::unique_ptr< const RexScalar > visitSubQuery(const RexSubQuery *rex_subquery) const override
std::unique_ptr< RexCase > parse_case(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
std::unordered_map< size_t, size_t > pushed_down_window_operands_offset_
void simplify_sort(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::vector< SortField > collation_
std::shared_ptr< RelJoin > dispatchJoin(const rapidjson::Value &join_ra, RelAlgDag &root_dag)
std::vector< std::unique_ptr< const RexScalar > > & new_rex_input_for_window_func_
void * defaultResult() const final
std::unordered_set< RexInput > RexInputSet
This file contains the class specification and related data structures for Catalog.
virtual T visit(const RexScalar *rex_scalar) const
bool hasCaseExprAsWindowOperand()
std::string to_string() const
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
virtual std::string toString(RelRexToStringConfig config) const =0
void separate_window_function_expressions(std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
WindowFunctionCollector(std::unordered_map< size_t, const RexScalar * > &collected_window_func)
bool aggregateResult(const bool &aggregate, const bool &next_result) const final
SQLOps getOperator() const
std::shared_ptr< RelTableFunction > dispatchTableFunction(const rapidjson::Value &table_func_ra, RelAlgDag &root_dag)
std::unordered_map< size_t, size_t > pushed_down_order_key_offset_
std::unordered_map< size_t, std::unique_ptr< const RexInput > > & new_rex_input_from_child_node_
std::set< std::pair< const RelAlgNode *, int > > get_equiv_cols(const RelAlgNode *node, const size_t which_col)
std::vector< std::string > & fields_for_new_project_
bool visitRef(const RexRef *) const final
std::unordered_set< size_t > & collected_window_func_hash_
std::unique_ptr< const RexScalar > visitInput(const RexInput *rex_input) const override
static QueryHint translateQueryHint(const std::string &hint_name)
DEVICE auto copy(ARGS &&...args)
Hints * getDeliveredHints()
size_t toHash() const override
void coalesce_nodes(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< const RelAlgNode * > &left_deep_joins, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
std::vector< std::string > fields_
static std::unique_ptr< RelAlgDag > build(const rapidjson::Value &query_ast, const Catalog_Namespace::Catalog &cat, RelAlgDag *root_dag, const bool optimize_dag)
SQLOps to_sql_op(const std::string &op_str)
std::unique_ptr< Hints > hints_
const int64_t json_i64(const rapidjson::Value &obj) noexcept
std::unique_ptr< Hints > hints_
std::vector< std::unique_ptr< const RexScalar > > copyRexScalars(std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources)
std::vector< std::shared_ptr< const RelAlgNode >> RelAlgInputs
std::vector< std::unique_ptr< const RexScalar > > scalar_exprs_
RetType visitOperator(const RexOperator *rex_operator) const final
bool defaultResult() const final
const double json_double(const rapidjson::Value &obj) noexcept
const std::vector< std::unique_ptr< const RexScalar > > & scalar_sources_
void addHint(const ExplainedQueryHint &hint_explained)
const unsigned FIRST_RA_NODE_ID
size_t branchCount() const
const RelAlgNode * getInput(const size_t idx) const
SQLTypeInfo parse_type(const rapidjson::Value &type_obj)
Checked json field retrieval.
RelFilter(std::unique_ptr< const RexScalar > &filter, std::shared_ptr< const RelAlgNode > input)
void * visitCase(const RexCase *rex_case) const final
std::vector< std::shared_ptr< RelAlgNode > > nodes_
RelAggregate(const size_t groupby_count, std::vector< std::unique_ptr< const RexAgg >> &agg_exprs, const std::vector< std::string > &fields, std::shared_ptr< const RelAlgNode > input)
std::unique_ptr< const RexScalar > filter_
std::vector< const Rex * > remapTargetPointers(std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_new, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_new, std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_old, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_old, std::vector< const Rex * > const &target_exprs_old)
std::optional< size_t > hash_
const size_t groupby_count_
void bind_inputs(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::optional< size_t > hash_
std::string toString(const Executor::ExtModuleKinds &kind)
virtual void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input)
void bind_project_to_input(RelProject *project_node, const RANodeOutput &input) noexcept
std::vector< std::unique_ptr< const RexScalar > > parse_expr_array(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
std::string tree_string(const RelAlgNode *ra, const size_t depth)
std::unordered_set< size_t > visited_
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
void compute_node_hash(const std::vector< std::shared_ptr< RelAlgNode >> &nodes)
Hints * getDeliveredHints()
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
size_t toHash() const override
PushDownGenericExpressionInWindowFunction(std::shared_ptr< RelProject > new_project, std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs_for_new_project, std::vector< std::string > &fields_for_new_project, std::unordered_map< size_t, size_t > &expr_offset_cache)
const RexScalar * getProjectAt(const size_t idx) const
RetType visitInput(const RexInput *input) const final
static std::unique_ptr< RelAlgDag > buildDag(const std::string &query_ra, const Catalog_Namespace::Catalog &cat, const bool optimize_dag)
static RegisteredQueryHint defaults()
int32_t countRexLiteralArgs() const
std::unique_ptr< Hints > hints_
std::vector< const Rex * > reproject_targets(const RelProject *simple_project, const std::vector< const Rex * > &target_exprs) noexcept
const ConstRexScalarPtrVector & getPartitionKeys() const
std::vector< std::shared_ptr< RelAlgNode > > run(const rapidjson::Value &rels, RelAlgDag &root_dag)
DEVICE auto lower_bound(ARGS &&...args)
std::unique_ptr< Hints > hints_
int64_t get_int_literal_field(const rapidjson::Value &obj, const char field[], const int64_t default_val) noexcept
const std::vector< const Rex * > target_exprs_
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
RelLogicalUnion(RelAlgInputs, bool is_all)
void registerSubquery(std::shared_ptr< RexSubQuery > subquery)
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
std::unique_ptr< const RexScalar > filter_expr_
static std::vector< std::shared_ptr< RelAlgNode > > & getNodes(RelAlgDag &rel_alg_dag)
bool hasWindowFunctionExpr() const
std::shared_ptr< RelModify > dispatchModify(const rapidjson::Value &logical_modify_ra)
std::vector< ElementType >::const_iterator Super
std::vector< std::unique_ptr< const RexAgg > > copyAggExprs(std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs)
std::unique_ptr< RexLiteral > parse_literal(const rapidjson::Value &expr)
std::vector< std::string > strings_from_json_array(const rapidjson::Value &json_str_arr) noexcept
std::unordered_map< QueryHint, ExplainedQueryHint > Hints
virtual size_t size() const =0
void setExecutionResult(const std::shared_ptr< const ExecutionResult > result)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
RelLogicalValues(const std::vector< TargetMetaInfo > &tuple_type, std::vector< RowValues > &values)
size_t toHash() const override
std::string typeName(const T *v)
ExplainedQueryHint parseHintString(std::string &hint_string)
void * visitOperator(const RexOperator *rex_operator) const final
bool is_window_function_operator(const RexScalar *rex)
void eachNode(std::function< void(RelAlgNode const *)> const &) const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::shared_ptr< RelSort > dispatchSort(const rapidjson::Value &sort_ra)
RexWindowFunctionOperator::RexWindowBound parse_window_bound(const rapidjson::Value &window_bound_obj, const Catalog_Namespace::Catalog &cat, RelAlgDag &root_dag)
RelTableFunction(const std::string &function_name, RelAlgInputs inputs, std::vector< std::string > &fields, std::vector< const Rex * > col_inputs, std::vector< std::unique_ptr< const RexScalar >> &table_func_inputs, std::vector< std::unique_ptr< const RexScalar >> &target_exprs)
const std::vector< std::string > & getFields() const
std::unique_ptr< const RexScalar > visitRef(const RexRef *rex_ref) const override
std::string getFieldName(const size_t i) const
static void optimizeDag(RelAlgDag &rel_alg_dag)
std::shared_ptr< RelProject > new_project_
bool g_enable_watchdog false
bool visitSubQuery(const RexSubQuery *) const final
const ConstRexScalarPtrVector & getOrderKeys() const
std::unordered_map< size_t, size_t > pushed_down_partition_key_offset_
RelProject(std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs, const std::vector< std::string > &fields, std::shared_ptr< const RelAlgNode > input)
bool hasPartitionExpression()
RexInputReplacementVisitor(const RelAlgNode *node_to_keep, const std::vector< std::unique_ptr< const RexScalar >> &scalar_sources)
void create_compound(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< size_t > &pattern, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints) noexcept
bool visitInput(const RexInput *input) const final
std::vector< RexInput > n_outputs(const RelAlgNode *node, const size_t n)
std::shared_ptr< const RelAlgNode > prev(const rapidjson::Value &crt_node)
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
void getRelAlgHints(const rapidjson::Value &json_node, std::shared_ptr< RelAlgNode > node)
virtual size_t toHash() const =0
SortDirection parse_sort_direction(const rapidjson::Value &collation)
RelAlgDispatcher(const Catalog_Namespace::Catalog &cat)
Common Enum definitions for SQL processing.
bool is_dict_encoded_string() const
bool found_case_expr_window_operand_
void fold_filters(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
const TableDescriptor * getMetadataForTable(const std::string &tableName, const bool populateFragmenter=true) const
Returns a pointer to a const TableDescriptor struct matching the provided tableName.
std::vector< std::unique_ptr< const RexScalar >> RowValues
void bind_table_func_to_input(RelTableFunction *table_func_node, const RANodeOutput &input) noexcept
bool is_window_function_sum(const RexScalar *rex)
RetType visitCase(const RexCase *rex_case) const final
const size_t inputCount() const
void rebind_inputs_from_left_deep_join(const RexScalar *rex, const RelLeftDeepInnerJoin *left_deep_join)
void check_empty_inputs_field(const rapidjson::Value &node) noexcept
unsigned node_id(const rapidjson::Value &ra_node) noexcept
const TableDescriptor * getTableFromScanNode(const Catalog_Namespace::Catalog &cat, const rapidjson::Value &scan_ra)
void eliminate_dead_subqueries(std::vector< std::shared_ptr< RexSubQuery >> &subqueries, RelAlgNode const *root)
size_t size() const override
size_t operator()(const std::pair< const RelAlgNode *, int > &input_col) const
std::unordered_map< size_t, size_t > & window_func_to_new_rex_input_idx_map_
RelAlgInputs getRelAlgInputs(const rapidjson::Value &node)
std::vector< std::string > getFieldNamesFromScanNode(const rapidjson::Value &scan_ra)
static std::unique_ptr< RelAlgDag > buildDagForSubquery(RelAlgDag &root_dag, const rapidjson::Value &query_ast, const Catalog_Namespace::Catalog &cat)
std::shared_ptr< RelLogicalValues > dispatchLogicalValues(const rapidjson::Value &logical_values_ra)
DEVICE void swap(ARGS &&...args)
std::unique_ptr< const RexScalar > RetType
size_t toHash() const override
RANodeOutput get_node_output(const RelAlgNode *ra_node)
virtual size_t toHash() const =0
bool visitLiteral(const RexLiteral *) const final
RelJoin(std::shared_ptr< const RelAlgNode > lhs, std::shared_ptr< const RelAlgNode > rhs, std::unique_ptr< const RexScalar > &condition, const JoinType join_type)
BuildState getBuildState() const
void set_precision(int d)
std::pair< std::string, std::string > getKVOptionPair(std::string &str, size_t &pos)
void eliminate_dead_columns(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::vector< std::unique_ptr< const RexScalar > > target_exprs_
static void setBuildState(RelAlgDag &rel_alg_dag, const RelAlgDag::BuildState build_state)
RelProject * new_project_
static void resetRelAlgFirstId() noexcept