28 #include <rapidjson/error/en.h>
29 #include <rapidjson/error/error.h>
30 #include <rapidjson/stringbuffer.h>
31 #include <rapidjson/writer.h>
34 #include <unordered_set>
52 const std::shared_ptr<const ExecutionResult>
result) {
53 auto row_set = result->getRows();
55 CHECK_EQ(
size_t(1), row_set->colCount());
56 *(type_.get()) = row_set->getColType(0);
57 (*(result_.get())) =
result;
61 return std::make_unique<RexSubQuery>(type_, result_, ra_->deepCopy());
73 : old_input_(old_input), new_input_(new_input) {}
79 if (old_source == old_input_) {
97 std::vector<RexInput> outputs;
99 for (
size_t i = 0; i <
n; ++i) {
100 outputs.emplace_back(node, i);
110 std::unordered_map<unsigned, unsigned> old_to_new_index_map)
114 RexRebindInputsVisitor::visitInput(rex_input);
115 auto mapping_itr = mapping_.find(rex_input->
getIndex());
116 CHECK(mapping_itr != mapping_.end());
117 rex_input->
setIndex(mapping_itr->second);
122 const std::unordered_map<unsigned, unsigned>
mapping_;
130 std::shared_ptr<RelProject> new_project,
131 std::vector<std::unique_ptr<const RexScalar>>& scalar_exprs_for_new_project,
132 std::vector<std::string>& fields_for_new_project,
133 std::unordered_map<size_t, size_t>& expr_offset_cache)
134 : new_project_(new_project)
135 , scalar_exprs_for_new_project_(scalar_exprs_for_new_project)
136 , fields_for_new_project_(fields_for_new_project)
137 , expr_offset_cache_(expr_offset_cache)
138 , found_case_expr_window_operand_(
false)
139 , has_partition_expr_(
false) {}
142 auto hash = expr->
toHash();
143 auto it = expr_offset_cache_.find(hash);
144 auto new_offset = -1;
145 if (it == expr_offset_cache_.end()) {
147 expr_offset_cache_.emplace(hash, scalar_exprs_for_new_project_.size()).second);
148 new_offset = scalar_exprs_for_new_project_.size();
149 fields_for_new_project_.emplace_back(
"");
150 scalar_exprs_for_new_project_.emplace_back(deep_copier_.visit(expr));
153 new_offset = it->second;
159 size_t expr_offset)
const {
163 case WindowExprType::PARTITION_KEY: {
164 auto it = pushed_down_partition_key_offset_.find(expr_offset);
165 CHECK(it != pushed_down_partition_key_offset_.end());
168 case WindowExprType::ORDER_KEY: {
169 auto it = pushed_down_order_key_offset_.find(expr_offset);
170 CHECK(it != pushed_down_order_key_offset_.end());
186 pushed_down_window_operands_offset_.clear();
187 pushed_down_partition_key_offset_.clear();
188 pushed_down_order_key_offset_.clear();
189 for (
size_t offset = 0; offset < window_expr->
size(); ++offset) {
191 auto literal_expr =
dynamic_cast<const RexLiteral*
>(expr);
192 auto case_expr =
dynamic_cast<const RexCase*
>(expr);
198 found_case_expr_window_operand_ =
true;
201 auto new_offset = pushDownExpressionImpl(expr);
202 pushed_down_window_operands_offset_.emplace(offset, new_offset);
207 auto new_offset = pushDownExpressionImpl(partition_key.get());
208 pushed_down_partition_key_offset_.emplace(offset, new_offset);
213 for (
const auto& order_key : window_expr->
getOrderKeys()) {
214 auto new_offset = pushDownExpressionImpl(order_key.get());
215 pushed_down_order_key_offset_.emplace(offset, new_offset);
221 std::vector<std::unique_ptr<const RexScalar>> window_operands;
223 for (
size_t idx = 0; idx < window_expr->
size(); ++idx) {
224 auto it = pushed_down_window_operands_offset_.find(idx);
225 if (it != pushed_down_window_operands_offset_.end()) {
226 auto new_input = std::make_unique<const RexInput>(new_project_.get(), it->second);
228 window_operands.emplace_back(std::move(new_input));
230 auto copied_expr = deep_copier_.visit(window_expr->
getOperand(idx));
231 window_operands.emplace_back(std::move(copied_expr));
234 deconst_window_expr->replaceOperands(std::move(window_operands));
237 auto new_offset = getOffsetForPushedDownExpr(WindowExprType::PARTITION_KEY, idx);
239 auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
241 deconst_window_expr->replacePartitionKey(idx, std::move(new_input));
244 for (
size_t idx = 0; idx < window_expr->
getOrderKeys().size(); ++idx) {
245 auto new_offset = getOffsetForPushedDownExpr(WindowExprType::ORDER_KEY, idx);
247 auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
249 deconst_window_expr->replaceOrderKey(idx, std::move(new_input));
254 auto new_offset = pushDownExpressionImpl(rex_input);
255 CHECK_LT(new_offset, scalar_exprs_for_new_project_.size());
256 auto hash = rex_input->
toHash();
257 auto it = expr_offset_cache_.find(hash);
258 CHECK(it != expr_offset_cache_.end());
260 auto new_input = std::make_unique<const RexInput>(new_project_.get(), new_offset);
266 const RexLiteral* rex_literal)
const override {
267 return deep_copier_.visit(rex_literal);
270 std::unique_ptr<const RexScalar>
visitRef(
const RexRef* rex_ref)
const override {
271 return deep_copier_.visit(rex_ref);
275 const RexSubQuery* rex_subquery)
const override {
276 return deep_copier_.visit(rex_subquery);
281 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
283 std::unique_ptr<const RexScalar> new_else_expr;
284 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
285 const auto when = rex_case->
getWhen(i);
286 auto new_when = PushDownGenericExpressionInWindowFunction::visit(when);
287 const auto then = rex_case->
getThen(i);
288 auto new_then = PushDownGenericExpressionInWindowFunction::visit(then);
289 new_expr_pair_list.emplace_back(std::move(new_when), std::move(new_then));
292 new_else_expr = deep_copier_.visit(rex_case->
getElse());
294 auto new_case = std::make_unique<const RexCase>(new_expr_pair_list, new_else_expr);
300 const auto rex_window_func_operator =
302 if (rex_window_func_operator) {
303 pushDownExpressionInWindowFunction(rex_window_func_operator);
304 return deep_copier_.visit(rex_operator);
306 std::unique_ptr<const RexOperator> new_operator{
nullptr};
307 std::vector<std::unique_ptr<const RexScalar>> new_operands;
308 for (
size_t i = 0; i < rex_operator->
size(); ++i) {
309 const auto operand = rex_operator->
getOperand(i);
310 auto new_operand = PushDownGenericExpressionInWindowFunction::visit(operand);
311 new_operands.emplace_back(std::move(new_operand));
313 if (
auto function_op = dynamic_cast<const RexFunctionOperator*>(rex_operator)) {
314 new_operator = std::make_unique<const RexFunctionOperator>(
315 function_op->getName(), new_operands, rex_operator->
getType());
317 new_operator = std::make_unique<const RexOperator>(
330 std::unique_ptr<const RexScalar>
defaultResult()
const override {
return nullptr; }
347 std::shared_ptr<const RelAlgNode> old_input,
348 std::shared_ptr<const RelAlgNode> input,
349 std::optional<std::unordered_map<unsigned, unsigned>> old_to_new_index_map) {
351 std::unique_ptr<RexRebindInputsVisitor> rebind_inputs;
352 if (old_to_new_index_map) {
353 rebind_inputs = std::make_unique<RexRebindReindexInputsVisitor>(
354 old_input.get(), input.get(), *old_to_new_index_map);
357 std::make_unique<RexRebindInputsVisitor>(old_input.get(), input.get());
359 CHECK(rebind_inputs);
361 rebind_inputs->visit(scalar_expr.get());
366 std::unique_ptr<const RexScalar> new_input) {
367 fields_.emplace_back(std::move(new_field_name));
372 const auto scan_node =
dynamic_cast<const RelScan*
>(ra_node);
375 CHECK_EQ(
size_t(0), scan_node->inputCount());
376 return n_outputs(scan_node, scan_node->size());
378 const auto project_node =
dynamic_cast<const RelProject*
>(ra_node);
381 CHECK_EQ(
size_t(1), project_node->inputCount());
382 return n_outputs(project_node, project_node->size());
384 const auto filter_node =
dynamic_cast<const RelFilter*
>(ra_node);
387 CHECK_EQ(
size_t(1), filter_node->inputCount());
389 return n_outputs(filter_node, prev_out.size());
391 const auto aggregate_node =
dynamic_cast<const RelAggregate*
>(ra_node);
392 if (aggregate_node) {
394 CHECK_EQ(
size_t(1), aggregate_node->inputCount());
395 return n_outputs(aggregate_node, aggregate_node->size());
397 const auto compound_node =
dynamic_cast<const RelCompound*
>(ra_node);
400 CHECK_EQ(
size_t(1), compound_node->inputCount());
401 return n_outputs(compound_node, compound_node->size());
403 const auto join_node =
dynamic_cast<const RelJoin*
>(ra_node);
407 CHECK_EQ(
size_t(2), join_node->inputCount());
412 lhs_out.insert(lhs_out.end(), rhs_out.begin(), rhs_out.end());
415 const auto table_func_node =
dynamic_cast<const RelTableFunction*
>(ra_node);
416 if (table_func_node) {
418 return n_outputs(table_func_node, table_func_node->size());
420 const auto sort_node =
dynamic_cast<const RelSort*
>(ra_node);
423 CHECK_EQ(
size_t(1), sort_node->inputCount());
425 return n_outputs(sort_node, prev_out.size());
427 const auto logical_values_node =
dynamic_cast<const RelLogicalValues*
>(ra_node);
428 if (logical_values_node) {
429 CHECK_EQ(
size_t(0), logical_values_node->inputCount());
430 return n_outputs(logical_values_node, logical_values_node->size());
432 const auto logical_union_node =
dynamic_cast<const RelLogicalUnion*
>(ra_node);
433 if (logical_union_node) {
434 return n_outputs(logical_union_node, logical_union_node->size());
446 if (dynamic_cast<const RelJoin*>(source)) {
455 const auto input =
dynamic_cast<const RexInput*
>(scalar_expr.get());
457 CHECK_EQ(source, input->getSourceNode());
461 if (input->getSourceNode() != source_shape[i].getSourceNode()) {
472 const std::string& new_name) {
474 if (
auto join = dynamic_cast<const RelJoin*>(node)) {
476 const auto lhs_size =
join->getInput(0)->size();
477 if (index < lhs_size) {
484 if (
auto scan = dynamic_cast<const RelScan*>(node)) {
485 return new_name != scan->getFieldName(index);
488 if (
auto aggregate = dynamic_cast<const RelAggregate*>(node)) {
489 return new_name != aggregate->getFieldName(index);
492 if (
auto project = dynamic_cast<const RelProject*>(node)) {
493 return new_name != project->getFieldName(index);
496 if (
auto table_func = dynamic_cast<const RelTableFunction*>(node)) {
497 return new_name != table_func->getFieldName(index);
500 if (
auto logical_values = dynamic_cast<const RelLogicalValues*>(node)) {
501 const auto& tuple_type = logical_values->getTupleType();
503 return new_name != tuple_type[index].get_resname();
506 CHECK(dynamic_cast<const RelSort*>(node) || dynamic_cast<const RelFilter*>(node) ||
507 dynamic_cast<const RelLogicalUnion*>(node));
518 for (
size_t i = 0; i <
fields_.size(); ++i) {
529 std::shared_ptr<const RelAlgNode> input) {
531 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
538 std::shared_ptr<const RelAlgNode> input) {
540 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
541 rebind_inputs.visit(
filter_.get());
545 std::shared_ptr<const RelAlgNode> input) {
547 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
549 rebind_inputs.visit(scalar_source.get());
559 , fields_(rhs.fields_)
560 , hint_applied_(
false)
561 , hints_(std::make_unique<
Hints>()) {
567 for (
auto const& kv : *rhs.
hints_) {
575 , tuple_type_(rhs.tuple_type_)
585 , groupby_count_(rhs.groupby_count_)
586 , fields_(rhs.fields_)
587 , hint_applied_(
false)
588 , hints_(std::make_unique<
Hints>()) {
594 for (
auto const& kv : *rhs.
hints_) {
602 , join_type_(rhs.join_type_)
603 , hint_applied_(
false)
604 , hints_(std::make_unique<
Hints>()) {
608 for (
auto const& kv : *rhs.
hints_) {
617 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs) {
618 std::vector<std::unique_ptr<const RexAgg>> agg_exprs_copy;
619 agg_exprs_copy.reserve(agg_exprs.size());
620 for (
auto const& agg_expr : agg_exprs) {
621 agg_exprs_copy.push_back(agg_expr->deepCopy());
623 return agg_exprs_copy;
627 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources) {
628 std::vector<std::unique_ptr<const RexScalar>> scalar_sources_copy;
629 scalar_sources_copy.reserve(scalar_sources.size());
631 for (
auto const& scalar_source : scalar_sources) {
632 scalar_sources_copy.push_back(copier.
visit(scalar_source.get()));
634 return scalar_sources_copy;
638 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs_new,
639 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources_new,
640 std::vector<std::unique_ptr<const RexAgg>>
const& agg_exprs_old,
641 std::vector<std::unique_ptr<const RexScalar>>
const& scalar_sources_old,
642 std::vector<const Rex*>
const& target_exprs_old) {
643 std::vector<const Rex*> target_exprs(target_exprs_old);
644 std::unordered_map<const Rex*, const Rex*> old_to_new_target(target_exprs.size());
645 for (
size_t i = 0; i < agg_exprs_new.size(); ++i) {
646 old_to_new_target.emplace(agg_exprs_old[i].
get(), agg_exprs_new[i].
get());
648 for (
size_t i = 0; i < scalar_sources_new.size(); ++i) {
649 old_to_new_target.emplace(scalar_sources_old[i].
get(), scalar_sources_new[i].
get());
651 for (
auto& target : target_exprs) {
652 auto target_it = old_to_new_target.find(target);
653 CHECK(target_it != old_to_new_target.end());
654 target = target_it->second;
664 , groupby_count_(rhs.groupby_count_)
666 , fields_(rhs.fields_)
667 , is_agg_(rhs.is_agg_)
674 , hint_applied_(
false)
675 , hints_(std::make_unique<
Hints>()) {
679 for (
auto const& kv : *rhs.
hints_) {
686 std::shared_ptr<const RelAlgNode> input) {
688 RexRebindInputsVisitor rebind_inputs(old_input.get(), input.get());
690 rebind_inputs.visit(target_expr.get());
693 rebind_inputs.visit(func_input.get());
698 int32_t literal_args = 0;
700 const auto rex_literal =
dynamic_cast<const RexLiteral*
>(arg.get());
710 , function_name_(rhs.function_name_)
711 , fields_(rhs.fields_)
712 , col_inputs_(rhs.col_inputs_)
715 std::unordered_map<const Rex*, const Rex*> old_to_new_input;
721 auto target_it = old_to_new_input.find(target);
722 CHECK(target_it != old_to_new_input.end());
723 target = target_it->second;
729 struct hash<std::pair<const RelAlgNode*, int>> {
730 size_t operator()(
const std::pair<const RelAlgNode*, int>& input_col)
const {
731 auto ptr_val =
reinterpret_cast<const int64_t*
>(&input_col.first);
732 return static_cast<int64_t
>(*ptr_val) ^ input_col.second;
740 const size_t which_col) {
741 std::set<std::pair<const RelAlgNode*, int>> work_set;
743 auto curr_col = which_col;
745 work_set.insert(std::make_pair(walker, curr_col));
746 if (dynamic_cast<const RelScan*>(walker) || dynamic_cast<const RelJoin*>(walker)) {
749 CHECK_EQ(
size_t(1), walker->inputCount());
750 auto only_source = walker->getInput(0);
751 if (
auto project = dynamic_cast<const RelProject*>(walker)) {
752 if (
auto input = dynamic_cast<const RexInput*>(project->getProjectAt(curr_col))) {
753 const auto join_source =
dynamic_cast<const RelJoin*
>(only_source);
755 CHECK_EQ(
size_t(2), join_source->inputCount());
756 auto lhs = join_source->getInput(0);
757 CHECK((input->getIndex() < lhs->size() && lhs == input->getSourceNode()) ||
758 join_source->getInput(1) == input->getSourceNode());
760 CHECK_EQ(input->getSourceNode(), only_source);
762 curr_col = input->getIndex();
766 }
else if (
auto aggregate = dynamic_cast<const RelAggregate*>(walker)) {
767 if (curr_col >= aggregate->getGroupByCount()) {
771 walker = only_source;
783 for (
size_t i = 0, e =
collation_.size(); i < e; ++i) {
786 if (this_sort_key.getSortDir() != that_sort_key.getSortDir()) {
789 if (this_sort_key.getNullsPosition() != that_sort_key.getNullsPosition()) {
792 auto this_equiv_keys =
get_equiv_cols(
this, this_sort_key.getField());
793 auto that_equiv_keys =
get_equiv_cols(&that, that_sort_key.getField());
794 std::vector<std::pair<const RelAlgNode*, int>> intersect;
795 std::set_intersection(this_equiv_keys.begin(),
796 this_equiv_keys.end(),
797 that_equiv_keys.begin(),
798 that_equiv_keys.end(),
799 std::back_inserter(intersect));
800 if (intersect.empty()) {
810 :
RelAlgNode(std::move(inputs)), is_all_(is_all) {
813 "The DEPRECATED enable-union option is set to off. Please remove this option as "
814 "it may be disabled in the future.");
823 return inputs_.front()->size();
839 if (
auto const* input = dynamic_cast<RelCompound const*>(
inputs_[0].
get())) {
840 return input->getFieldName(i);
841 }
else if (
auto const* input = dynamic_cast<RelProject const*>(
inputs_[0].
get())) {
842 return input->getFieldName(i);
843 }
else if (
auto const* input = dynamic_cast<RelLogicalUnion const*>(
inputs_[0].
get())) {
844 return input->getFieldName(i);
845 }
else if (
auto const* input = dynamic_cast<RelAggregate const*>(
inputs_[0].
get())) {
846 return input->getFieldName(i);
847 }
else if (
auto const* input = dynamic_cast<RelScan const*>(
inputs_[0].
get())) {
848 return input->getFieldName(i);
849 }
else if (
auto const* input =
850 dynamic_cast<RelTableFunction const*>(
inputs_[0].
get())) {
851 return input->getFieldName(i);
858 std::vector<TargetMetaInfo>
const& tmis0 =
inputs_[0]->getOutputMetainfo();
859 std::vector<TargetMetaInfo>
const& tmis1 =
inputs_[1]->getOutputMetainfo();
860 if (tmis0.size() != tmis1.size()) {
861 VLOG(2) <<
"tmis0.size() = " << tmis0.size() <<
" != " << tmis1.size()
862 <<
" = tmis1.size()";
863 throw std::runtime_error(
"Subqueries of a UNION must have matching data types.");
865 for (
size_t i = 0; i < tmis0.size(); ++i) {
866 if (tmis0[i].get_type_info() != tmis1[i].get_type_info()) {
869 VLOG(2) <<
"Types do not match for UNION:\n tmis0[" << i
870 <<
"].get_type_info().to_string() = " << ti0.
to_string() <<
"\n tmis1["
871 << i <<
"].get_type_info().to_string() = " << ti1.
to_string();
874 throw std::runtime_error(
875 "Subqueries of a UNION must have the exact same data types.");
883 size_t input_idx)
const {
884 if (
auto const* rex_input_ptr = dynamic_cast<RexInput const*>(rex_scalar)) {
887 scalar_exprs_.emplace_back(std::make_shared<RexInput const>(std::move(rex_input)));
895 unsigned node_id(
const rapidjson::Value& ra_node) noexcept {
896 const auto&
id =
field(ra_node,
"id");
901 rapidjson::StringBuffer buffer;
902 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
904 return buffer.GetString();
912 const rapidjson::Value& expr) noexcept {
913 const auto& input =
field(expr,
"input");
918 CHECK(expr.IsObject());
919 const auto& literal =
field(expr,
"literal");
925 const auto type_precision =
json_i64(
field(expr,
"type_precision"));
926 if (literal.IsNull()) {
927 return std::unique_ptr<RexLiteral>(
new RexLiteral(target_type));
938 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_i64(literal),
946 if (literal.IsDouble()) {
947 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_double(literal),
954 }
else if (literal.IsInt64()) {
955 return std::make_unique<RexLiteral>(
static_cast<double>(literal.GetInt64()),
963 }
else if (literal.IsUint64()) {
964 return std::make_unique<RexLiteral>(
static_cast<double>(literal.GetUint64()),
972 UNREACHABLE() <<
"Unhandled type: " << literal.GetType();
975 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_str(literal),
983 return std::unique_ptr<RexLiteral>(
new RexLiteral(
json_bool(literal),
991 return std::unique_ptr<RexLiteral>(
new RexLiteral(target_type));
1004 if (type_obj.IsArray()) {
1007 CHECK(type_obj.IsObject() && type_obj.MemberCount() >= 2)
1011 const auto precision_it = type_obj.FindMember(
"precision");
1012 const int precision =
1013 precision_it != type_obj.MemberEnd() ?
json_i64(precision_it->value) : 0;
1014 const auto scale_it = type_obj.FindMember(
"scale");
1015 const int scale = scale_it != type_obj.MemberEnd() ?
json_i64(scale_it->value) : 0;
1023 const rapidjson::Value& arr,
1026 std::vector<std::unique_ptr<const RexScalar>> exprs;
1027 for (
auto it = arr.Begin(); it != arr.End(); ++it) {
1034 if (name ==
"ROW_NUMBER") {
1037 if (name ==
"RANK") {
1040 if (name ==
"DENSE_RANK") {
1043 if (name ==
"PERCENT_RANK") {
1046 if (name ==
"CUME_DIST") {
1049 if (name ==
"NTILE") {
1052 if (name ==
"LAG") {
1055 if (name ==
"LEAD") {
1058 if (name ==
"FIRST_VALUE") {
1061 if (name ==
"LAST_VALUE") {
1064 if (name ==
"AVG") {
1067 if (name ==
"MIN") {
1070 if (name ==
"MAX") {
1073 if (name ==
"SUM") {
1076 if (name ==
"COUNT") {
1079 if (name ==
"$SUM0") {
1082 throw std::runtime_error(
"Unsupported window function: " + name);
1086 const rapidjson::Value& arr,
1089 std::vector<std::unique_ptr<const RexScalar>> exprs;
1090 for (
auto it = arr.Begin(); it != arr.End(); ++it) {
1097 return json_str(
field(collation,
"direction")) == std::string(
"DESCENDING")
1103 return json_str(
field(collation,
"nulls")) == std::string(
"FIRST")
1111 std::vector<SortField> collation;
1112 size_t field_idx = 0;
1113 for (
auto it = arr.Begin(); it != arr.End(); ++it, ++field_idx) {
1116 collation.emplace_back(field_idx, sort_dir, null_pos);
1122 const rapidjson::Value& window_bound_obj,
1125 CHECK(window_bound_obj.IsObject());
1128 window_bound.preceding =
json_bool(
field(window_bound_obj,
"preceding"));
1129 window_bound.following =
json_bool(
field(window_bound_obj,
"following"));
1130 window_bound.is_current_row =
json_bool(
field(window_bound_obj,
"is_current_row"));
1131 const auto& offset_field =
field(window_bound_obj,
"offset");
1132 if (offset_field.IsObject()) {
1135 CHECK(offset_field.IsNull());
1137 window_bound.order_key =
json_i64(
field(window_bound_obj,
"order_key"));
1138 return window_bound;
1144 const auto& operands =
field(expr,
"operands");
1145 CHECK(operands.IsArray());
1146 CHECK_GE(operands.Size(), unsigned(0));
1147 const auto& subquery_ast =
field(expr,
"subquery");
1149 RelAlgDagBuilder subquery_dag(root_dag_builder, subquery_ast, cat,
nullptr);
1150 auto subquery = std::make_shared<RexSubQuery>(subquery_dag.
getRootNodeShPtr());
1152 return subquery->deepCopy();
1159 const bool is_quantifier =
1160 op_name == std::string(
"PG_ANY") || op_name == std::string(
"PG_ALL");
1162 const auto& operators_json_arr =
field(expr,
"operands");
1163 CHECK(operators_json_arr.IsArray());
1164 auto operands =
parse_expr_array(operators_json_arr, cat, root_dag_builder);
1165 const auto type_it = expr.FindMember(
"type");
1166 CHECK(type_it != expr.MemberEnd());
1168 if (op ==
kIN && expr.HasMember(
"subquery")) {
1170 operands.emplace_back(std::move(subquery));
1172 if (expr.FindMember(
"partition_keys") != expr.MemberEnd()) {
1173 const auto& partition_keys_arr =
field(expr,
"partition_keys");
1174 auto partition_keys =
parse_expr_array(partition_keys_arr, cat, root_dag_builder);
1175 const auto& order_keys_arr =
field(expr,
"order_keys");
1177 const auto collation =
1185 ti.set_notnull(
false);
1186 return std::make_unique<RexWindowFunctionOperator>(kind,
1196 return std::unique_ptr<RexOperator>(op ==
kFUNCTION
1201 std::unique_ptr<RexCase>
parse_case(
const rapidjson::Value& expr,
1204 const auto& operands =
field(expr,
"operands");
1205 CHECK(operands.IsArray());
1206 CHECK_GE(operands.Size(), unsigned(2));
1207 std::unique_ptr<const RexScalar> else_expr;
1209 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
1211 for (
auto operands_it = operands.Begin(); operands_it != operands.End();) {
1213 if (operands_it == operands.End()) {
1214 else_expr = std::move(when_expr);
1218 expr_pair_list.emplace_back(std::move(when_expr), std::move(then_expr));
1220 return std::unique_ptr<RexCase>(
new RexCase(expr_pair_list, else_expr));
1224 const rapidjson::Value& json_str_arr) noexcept {
1225 CHECK(json_str_arr.IsArray());
1226 std::vector<std::string> fields;
1227 for (
auto json_str_arr_it = json_str_arr.Begin(); json_str_arr_it != json_str_arr.End();
1228 ++json_str_arr_it) {
1229 CHECK(json_str_arr_it->IsString());
1230 fields.emplace_back(json_str_arr_it->GetString());
1236 const rapidjson::Value& json_idx_arr) noexcept {
1237 CHECK(json_idx_arr.IsArray());
1238 std::vector<size_t> indices;
1239 for (
auto json_idx_arr_it = json_idx_arr.Begin(); json_idx_arr_it != json_idx_arr.End();
1240 ++json_idx_arr_it) {
1241 CHECK(json_idx_arr_it->IsInt());
1242 CHECK_GE(json_idx_arr_it->GetInt(), 0);
1243 indices.emplace_back(json_idx_arr_it->GetInt());
1250 if (agg_str ==
"APPROX_QUANTILE") {
1251 LOG(
INFO) <<
"APPROX_QUANTILE is deprecated. Please use APPROX_PERCENTILE instead.";
1261 return std::unique_ptr<const RexAgg>(
new RexAgg(agg, distinct, agg_ti, operands));
1267 CHECK(expr.IsObject());
1268 if (expr.IsObject() && expr.HasMember(
"input")) {
1271 if (expr.IsObject() && expr.HasMember(
"literal")) {
1272 return std::unique_ptr<const RexScalar>(
parse_literal(expr));
1274 if (expr.IsObject() && expr.HasMember(
"op")) {
1276 if (op_str == std::string(
"CASE")) {
1277 return std::unique_ptr<const RexScalar>(
parse_case(expr, cat, root_dag_builder));
1279 if (op_str == std::string(
"$SCALAR_QUERY")) {
1280 return std::unique_ptr<const RexScalar>(
1283 return std::unique_ptr<const RexScalar>(
parse_operator(expr, cat, root_dag_builder));
1290 if (join_type_name ==
"inner") {
1293 if (join_type_name ==
"left") {
1296 if (join_type_name ==
"semi") {
1299 if (join_type_name ==
"anti") {
1310 std::vector<std::unique_ptr<const RexScalar>> disambiguated_operands;
1311 for (
size_t i = 0; i < rex_operator->size(); ++i) {
1312 auto operand = rex_operator->getOperand(i);
1313 if (dynamic_cast<const RexSubQuery*>(operand)) {
1314 disambiguated_operands.emplace_back(rex_operator->getOperandAndRelease(i));
1319 const auto rex_window_function_operator =
1321 if (rex_window_function_operator) {
1322 const auto& partition_keys = rex_window_function_operator->
getPartitionKeys();
1323 std::vector<std::unique_ptr<const RexScalar>> disambiguated_partition_keys;
1324 for (
const auto& partition_key : partition_keys) {
1325 disambiguated_partition_keys.emplace_back(
1328 std::vector<std::unique_ptr<const RexScalar>> disambiguated_order_keys;
1329 const auto& order_keys = rex_window_function_operator->getOrderKeys();
1330 for (
const auto& order_key : order_keys) {
1331 disambiguated_order_keys.emplace_back(
disambiguate_rex(order_key.get(), ra_output));
1333 return rex_window_function_operator->disambiguatedOperands(
1334 disambiguated_operands,
1335 disambiguated_partition_keys,
1336 disambiguated_order_keys,
1337 rex_window_function_operator->getCollation());
1339 return rex_operator->getDisambiguated(disambiguated_operands);
1345 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
1346 disambiguated_expr_pair_list;
1347 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
1350 disambiguated_expr_pair_list.emplace_back(std::move(disambiguated_when),
1351 std::move(disambiguated_then));
1353 std::unique_ptr<const RexScalar> disambiguated_else{
1355 return std::unique_ptr<const RexCase>(
1356 new RexCase(disambiguated_expr_pair_list, disambiguated_else));
1365 const auto rex_abstract_input =
dynamic_cast<const RexAbstractInput*
>(rex_scalar);
1366 if (rex_abstract_input) {
1367 CHECK_LT(static_cast<size_t>(rex_abstract_input->getIndex()), ra_output.size());
1368 return std::unique_ptr<const RexInput>(
1369 new RexInput(ra_output[rex_abstract_input->getIndex()]));
1371 const auto rex_operator =
dynamic_cast<const RexOperator*
>(rex_scalar);
1375 const auto rex_case =
dynamic_cast<const RexCase*
>(rex_scalar);
1379 if (
auto const rex_literal = dynamic_cast<const RexLiteral*>(rex_scalar)) {
1380 return rex_literal->deepCopy();
1381 }
else if (
auto const rex_subquery = dynamic_cast<const RexSubQuery*>(rex_scalar)) {
1382 return rex_subquery->deepCopy();
1385 std::string(
typeid(*rex_scalar).name()));
1390 CHECK_EQ(
size_t(1), project_node->inputCount());
1391 std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
1392 for (
size_t i = 0; i < project_node->size(); ++i) {
1393 const auto projected_expr = project_node->getProjectAt(i);
1394 if (dynamic_cast<const RexSubQuery*>(projected_expr)) {
1395 disambiguated_exprs.emplace_back(project_node->getProjectAtAndRelease(i));
1400 project_node->setExpressions(disambiguated_exprs);
1405 std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
1406 for (
size_t i = 0; i < table_func_node->getTableFuncInputsSize(); ++i) {
1407 const auto target_expr = table_func_node->getTableFuncInputAt(i);
1408 if (dynamic_cast<const RexSubQuery*>(target_expr)) {
1409 disambiguated_exprs.emplace_back(table_func_node->getTableFuncInputAtAndRelease(i));
1414 table_func_node->setTableFuncInputs(disambiguated_exprs);
1417 void bind_inputs(
const std::vector<std::shared_ptr<RelAlgNode>>& nodes) noexcept {
1418 for (
auto ra_node : nodes) {
1419 const auto filter_node = std::dynamic_pointer_cast<
RelFilter>(ra_node);
1421 CHECK_EQ(
size_t(1), filter_node->inputCount());
1423 filter_node->getCondition(),
get_node_output(filter_node->getInput(0)));
1424 filter_node->setCondition(disambiguated_condition);
1427 const auto join_node = std::dynamic_pointer_cast<
RelJoin>(ra_node);
1429 CHECK_EQ(
size_t(2), join_node->inputCount());
1430 auto disambiguated_condition =
1432 join_node->setCondition(disambiguated_condition);
1435 const auto project_node = std::dynamic_pointer_cast<
RelProject>(ra_node);
1441 const auto table_func_node = std::dynamic_pointer_cast<
RelTableFunction>(ra_node);
1442 if (table_func_node) {
1448 input.reserve(table_func_node->inputCount());
1449 for (
size_t i = 0; i < table_func_node->inputCount(); i++) {
1451 input.insert(input.end(), node_output.begin(), node_output.end());
1464 for (
auto node : nodes) {
1465 Hints* hint_delivered =
nullptr;
1466 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
1468 if (agg_node->hasDeliveredHint()) {
1472 const auto project_node = std::dynamic_pointer_cast<
RelProject>(node);
1474 if (project_node->hasDeliveredHint()) {
1478 const auto compound_node = std::dynamic_pointer_cast<
RelCompound>(node);
1479 if (compound_node) {
1480 if (compound_node->hasDeliveredHint()) {
1484 if (hint_delivered && !hint_delivered->empty()) {
1485 dag_builder->registerQueryHints(node, hint_delivered, global_query_hint);
1488 dag_builder->setGlobalQueryHints(global_query_hint);
1499 nodes.rbegin(), nodes.rend(), [](
const std::shared_ptr<RelAlgNode>& node) {
1500 auto node_hash = node->toHash();
1501 CHECK_NE(node_hash, static_cast<size_t>(0));
1505 void mark_nops(
const std::vector<std::shared_ptr<RelAlgNode>>& nodes) noexcept {
1506 for (
auto node : nodes) {
1507 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
1508 if (!agg_node || agg_node->getAggExprsCount()) {
1511 CHECK_EQ(
size_t(1), node->inputCount());
1512 const auto agg_input_node =
dynamic_cast<const RelAggregate*
>(node->getInput(0));
1513 if (agg_input_node && !agg_input_node->getAggExprsCount() &&
1514 agg_node->getGroupByCount() == agg_input_node->getGroupByCount()) {
1524 const std::vector<const Rex*>& target_exprs) noexcept {
1525 std::vector<const Rex*>
result;
1526 for (
size_t i = 0; i < simple_project->size(); ++i) {
1527 const auto input_rex =
dynamic_cast<const RexInput*
>(simple_project->getProjectAt(i));
1529 CHECK_LT(static_cast<size_t>(input_rex->getIndex()), target_exprs.size());
1530 result.push_back(target_exprs[input_rex->getIndex()]);
1544 const std::vector<std::unique_ptr<const RexScalar>>& scalar_sources)
1545 : node_to_keep_(node_to_keep), scalar_sources_(scalar_sources) {}
1549 if (input->getSourceNode() == node_to_keep_) {
1550 const auto index = input->getIndex();
1551 CHECK_LT(index, scalar_sources_.size());
1552 return visit(scalar_sources_[index].
get());
1554 return input->deepCopy();
1566 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
1567 const std::vector<size_t>& pattern,
1568 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
1569 query_hints) noexcept {
1570 CHECK_GE(pattern.size(), size_t(2));
1571 CHECK_LE(pattern.size(), size_t(4));
1573 std::unique_ptr<const RexScalar> filter_rex;
1574 std::vector<std::unique_ptr<const RexScalar>> scalar_sources;
1575 size_t groupby_count{0};
1576 std::vector<std::string> fields;
1577 std::vector<const RexAgg*> agg_exprs;
1578 std::vector<const Rex*> target_exprs;
1579 bool first_project{
true};
1583 std::shared_ptr<ModifyManipulationTarget> manipulation_target;
1584 size_t node_hash{0};
1586 bool hint_registered{
false};
1588 for (
const auto node_idx : pattern) {
1589 const auto ra_node = nodes[node_idx];
1590 auto registered_query_hint_map_it = query_hints.find(ra_node->toHash());
1591 if (registered_query_hint_map_it != query_hints.end()) {
1592 auto& registered_query_hint_map = registered_query_hint_map_it->second;
1593 auto registered_query_hint_it = registered_query_hint_map.find(ra_node->getId());
1594 if (registered_query_hint_it != registered_query_hint_map.end()) {
1595 hint_registered =
true;
1596 node_hash = registered_query_hint_map_it->first;
1597 node_id = registered_query_hint_it->first;
1598 registered_query_hint = registered_query_hint_it->second;
1601 const auto ra_filter = std::dynamic_pointer_cast<
RelFilter>(ra_node);
1604 filter_rex.reset(ra_filter->getAndReleaseCondition());
1606 last_node = ra_node.get();
1609 const auto ra_project = std::dynamic_pointer_cast<
RelProject>(ra_node);
1612 manipulation_target = ra_project;
1614 if (first_project) {
1615 CHECK_EQ(
size_t(1), ra_project->inputCount());
1619 const auto filter_input =
dynamic_cast<const RelFilter*
>(ra_project->getInput(0));
1621 CHECK_EQ(
size_t(1), filter_input->inputCount());
1625 scalar_sources = ra_project->getExpressionsAndRelease();
1626 for (
const auto& scalar_expr : scalar_sources) {
1627 target_exprs.push_back(scalar_expr.get());
1629 first_project =
false;
1631 if (ra_project->isSimple()) {
1636 std::vector<const Rex*>
result;
1637 RexInputReplacementVisitor visitor(last_node, scalar_sources);
1638 for (
size_t i = 0; i < ra_project->size(); ++i) {
1639 const auto rex = ra_project->getProjectAt(i);
1640 if (
auto rex_input = dynamic_cast<const RexInput*>(rex)) {
1641 const auto index = rex_input->getIndex();
1642 CHECK_LT(index, target_exprs.size());
1643 result.push_back(target_exprs[index]);
1645 scalar_sources.push_back(visitor.visit(rex));
1646 result.push_back(scalar_sources.back().get());
1652 last_node = ra_node.get();
1655 const auto ra_aggregate = std::dynamic_pointer_cast<
RelAggregate>(ra_node);
1658 fields = ra_aggregate->getFields();
1659 agg_exprs = ra_aggregate->getAggregatesAndRelease();
1660 groupby_count = ra_aggregate->getGroupByCount();
1661 decltype(target_exprs){}.swap(target_exprs);
1662 CHECK_LE(groupby_count, scalar_sources.size());
1663 for (
size_t group_idx = 0; group_idx < groupby_count; ++group_idx) {
1664 const auto rex_ref =
new RexRef(group_idx + 1);
1665 target_exprs.push_back(rex_ref);
1666 scalar_sources.emplace_back(rex_ref);
1668 for (
const auto rex_agg : agg_exprs) {
1669 target_exprs.push_back(rex_agg);
1671 last_node = ra_node.get();
1676 auto compound_node =
1677 std::make_shared<RelCompound>(filter_rex,
1684 manipulation_target->isUpdateViaSelect(),
1685 manipulation_target->isDeleteViaSelect(),
1686 manipulation_target->isVarlenUpdateRequired(),
1687 manipulation_target->getModifiedTableDescriptor(),
1688 manipulation_target->getTargetColumns());
1689 auto old_node = nodes[pattern.back()];
1690 nodes[pattern.back()] = compound_node;
1691 auto first_node = nodes[pattern.front()];
1692 CHECK_EQ(
size_t(1), first_node->inputCount());
1693 compound_node->addManagedInput(first_node->getAndOwnInput(0));
1694 if (hint_registered) {
1697 auto registered_query_hint_map_it = query_hints.find(node_hash);
1698 CHECK(registered_query_hint_map_it != query_hints.end());
1699 auto registered_query_hint_map = registered_query_hint_map_it->second;
1700 if (registered_query_hint_map.size() > 1) {
1701 registered_query_hint_map.erase(
node_id);
1703 CHECK_EQ(registered_query_hint_map.size(),
static_cast<size_t>(1));
1704 query_hints.erase(node_hash);
1706 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
1707 hint_map.emplace(compound_node->getId(), registered_query_hint);
1708 query_hints.emplace(compound_node->toHash(), hint_map);
1710 for (
size_t i = 0; i < pattern.size() - 1; ++i) {
1711 nodes[pattern[i]].reset();
1713 for (
auto node : nodes) {
1717 node->replaceInput(old_node, compound_node);
1721 class RANodeIterator :
public std::vector<std::shared_ptr<RelAlgNode>>::const_iterator {
1723 using Super = std::vector<ElementType>::const_iterator;
1730 : Super(nodes.begin()), owner_(nodes), nodeCount_([&nodes]() -> size_t {
1731 size_t non_zero_count = 0;
1732 for (
const auto& node : nodes) {
1740 explicit operator size_t() {
1741 return std::distance(owner_.begin(), *
static_cast<Super*
>(
this));
1744 RANodeIterator operator++() =
delete;
1747 Super& super = *
this;
1749 case AdvancingMode::DUChain: {
1750 size_t use_count = 0;
1751 Super only_use = owner_.end();
1752 for (
Super nodeIt = std::next(super); nodeIt != owner_.end(); ++nodeIt) {
1756 for (
size_t i = 0; i < (*nodeIt)->inputCount(); ++i) {
1757 if ((*super) == (*nodeIt)->getAndOwnInput(i)) {
1759 if (1 == use_count) {
1762 super = owner_.end();
1771 case AdvancingMode::InOrder:
1772 for (
size_t i = 0; i != owner_.size(); ++i) {
1773 if (!visited_.count(i)) {
1774 super = owner_.begin();
1775 std::advance(super, i);
1779 super = owner_.end();
1789 visited_.insert(
size_t(*
this));
1790 Super& super = *
this;
1806 const bool first_rex_is_input) {
1807 if (
auto agg_node = dynamic_cast<const RelAggregate*>(parent_node)) {
1808 if (index == 0 && agg_node->getGroupByCount() > 0) {
1814 return first_rex_is_input;
1817 return first_rex_is_input;
1842 return aggregate && next_result;
1850 const auto case_operator =
dynamic_cast<const RexCase*
>(rex);
1851 if (case_operator && case_operator->branchCount() == 1) {
1852 const auto then_window =
1867 const auto case_operator =
1869 const auto second_window =
1871 if (case_operator && second_window &&
1884 if (dynamic_cast<const RexWindowFunctionOperator*>(rex)) {
1889 const auto rex_cast =
dynamic_cast<const RexOperator*
>(rex);
1890 if (rex_cast && rex_cast->getOperator() ==
kCAST) {
1891 CHECK_EQ(rex_cast->size(), size_t(1));
1905 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
1906 const std::vector<const RelAlgNode*>& left_deep_joins,
1907 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
1909 enum class CoalesceState { Initial, Filter, FirstProject, Aggregate };
1910 std::vector<size_t> crt_pattern;
1911 CoalesceState crt_state{CoalesceState::Initial};
1913 auto reset_state = [&crt_pattern, &crt_state]() {
1914 crt_state = CoalesceState::Initial;
1915 std::vector<size_t>().
swap(crt_pattern);
1919 const auto ra_node = nodeIt != nodes.end() ? *nodeIt :
nullptr;
1920 switch (crt_state) {
1921 case CoalesceState::Initial: {
1922 if (std::dynamic_pointer_cast<const RelFilter>(ra_node) &&
1923 std::find(left_deep_joins.begin(), left_deep_joins.end(), ra_node.get()) ==
1924 left_deep_joins.end()) {
1925 crt_pattern.push_back(
size_t(nodeIt));
1926 crt_state = CoalesceState::Filter;
1927 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1928 }
else if (
auto project_node =
1929 std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1930 if (project_node->hasWindowFunctionExpr()) {
1931 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1933 crt_pattern.push_back(
size_t(nodeIt));
1934 crt_state = CoalesceState::FirstProject;
1935 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1938 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1942 case CoalesceState::Filter: {
1943 if (
auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1946 CHECK(!project_node->hasWindowFunctionExpr());
1947 crt_pattern.push_back(
size_t(nodeIt));
1948 crt_state = CoalesceState::FirstProject;
1949 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1955 case CoalesceState::FirstProject: {
1956 if (std::dynamic_pointer_cast<const RelAggregate>(ra_node)) {
1957 crt_pattern.push_back(
size_t(nodeIt));
1958 crt_state = CoalesceState::Aggregate;
1959 nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
1961 if (crt_pattern.size() >= 2) {
1968 case CoalesceState::Aggregate: {
1969 if (
auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
1970 if (!project_node->hasWindowFunctionExpr()) {
1972 bool is_simple_project{
true};
1973 for (
size_t i = 0; i < project_node->size(); i++) {
1974 const auto scalar_rex = project_node->getProjectAt(i);
1976 if (
auto input_rex = dynamic_cast<const RexInput*>(scalar_rex)) {
1978 input_rex->getSourceNode(), input_rex->getIndex(),
true)) {
1979 is_simple_project =
false;
1984 CoalesceSecondaryProjectVisitor visitor;
1985 if (!visitor.visit(project_node->getProjectAt(i))) {
1986 is_simple_project =
false;
1990 if (is_simple_project) {
1991 crt_pattern.push_back(
size_t(nodeIt));
1992 nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
1996 CHECK_GE(crt_pattern.size(), size_t(2));
2005 if (crt_state == CoalesceState::FirstProject || crt_state == CoalesceState::Aggregate) {
2006 if (crt_pattern.size() >= 2) {
2009 CHECK(!crt_pattern.empty());
2016 std::unordered_map<size_t, const RexScalar*>& collected_window_func)
2017 : collected_window_func_(collected_window_func) {}
2023 collected_window_func_.emplace(rex_operator->toHash(), rex_operator);
2025 const size_t operand_count = rex_operator->size();
2026 for (
size_t i = 0; i < operand_count; ++i) {
2027 const auto operand = rex_operator->getOperand(i);
2031 collected_window_func_.emplace(operand->toHash(), operand);
2036 return defaultResult();
2045 collected_window_func_.emplace(rex_case->
toHash(), rex_case);
2049 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
2050 const auto when = rex_case->
getWhen(i);
2052 collected_window_func_.emplace(when->toHash(), when);
2056 const auto then = rex_case->
getThen(i);
2058 collected_window_func_.emplace(then->toHash(), then);
2064 auto else_expr = rex_case->
getElse();
2066 collected_window_func_.emplace(else_expr->toHash(), else_expr);
2071 return defaultResult();
2083 std::unordered_set<size_t>& collected_window_func_hash,
2084 std::vector<std::unique_ptr<const RexScalar>>& new_rex_input_for_window_func,
2085 std::unordered_map<size_t, size_t>& window_func_to_new_rex_input_idx_map,
2087 std::unordered_map<
size_t, std::unique_ptr<const RexInput>>&
2088 new_rex_input_from_child_node)
2089 : collected_window_func_hash_(collected_window_func_hash)
2090 , new_rex_input_for_window_func_(new_rex_input_for_window_func)
2091 , window_func_to_new_rex_input_idx_map_(window_func_to_new_rex_input_idx_map)
2092 , new_project_(new_project)
2093 , new_rex_input_from_child_node_(new_rex_input_from_child_node) {
2094 CHECK_EQ(collected_window_func_hash_.size(),
2095 window_func_to_new_rex_input_idx_map_.size());
2096 for (
auto hash : collected_window_func_hash_) {
2097 auto rex_it = window_func_to_new_rex_input_idx_map_.find(hash);
2098 CHECK(rex_it != window_func_to_new_rex_input_idx_map_.end());
2099 CHECK_LT(rex_it->second, new_rex_input_for_window_func_.size());
2101 CHECK(new_project_);
2106 if (rex_input->getSourceNode() != new_project_) {
2107 const auto cur_index = rex_input->getIndex();
2108 auto cur_source_node = rex_input->getSourceNode();
2109 std::string field_name =
"";
2110 if (
auto cur_project_node = dynamic_cast<const RelProject*>(cur_source_node)) {
2111 field_name = cur_project_node->getFieldName(cur_index);
2113 auto rex_input_hash = rex_input->toHash();
2114 auto rex_input_it = new_rex_input_from_child_node_.find(rex_input_hash);
2115 if (rex_input_it == new_rex_input_from_child_node_.end()) {
2116 auto new_rex_input =
2117 std::make_unique<RexInput>(new_project_, new_project_->size());
2118 new_project_->appendInput(field_name, rex_input->deepCopy());
2119 new_rex_input_from_child_node_.emplace(rex_input_hash, new_rex_input->deepCopy());
2120 return new_rex_input;
2122 return rex_input_it->second->deepCopy();
2125 return rex_input->deepCopy();
2130 auto new_rex_idx = is_collected_window_function(rex_operator->toHash());
2132 return get_new_rex_input(*new_rex_idx);
2135 const auto rex_window_function_operator =
2137 if (rex_window_function_operator) {
2139 return visitWindowFunctionOperator(rex_window_function_operator);
2142 const size_t operand_count = rex_operator->size();
2143 std::vector<RetType> new_opnds;
2144 for (
size_t i = 0; i < operand_count; ++i) {
2145 const auto operand = rex_operator->getOperand(i);
2146 auto new_rex_idx_for_operand = is_collected_window_function(operand->toHash());
2147 if (new_rex_idx_for_operand) {
2148 new_opnds.push_back(get_new_rex_input(*new_rex_idx_for_operand));
2150 new_opnds.emplace_back(visit(rex_operator->getOperand(i)));
2153 return rex_operator->getDisambiguated(new_opnds);
2157 auto new_rex_idx = is_collected_window_function(rex_case->
toHash());
2159 return get_new_rex_input(*new_rex_idx);
2162 std::vector<std::pair<RetType, RetType>> new_pair_list;
2163 for (
size_t i = 0; i < rex_case->
branchCount(); ++i) {
2164 auto when_operand = rex_case->
getWhen(i);
2165 auto new_rex_idx_for_when_operand =
2166 is_collected_window_function(when_operand->toHash());
2168 auto then_operand = rex_case->
getThen(i);
2169 auto new_rex_idx_for_then_operand =
2170 is_collected_window_function(then_operand->toHash());
2172 new_pair_list.emplace_back(
2173 new_rex_idx_for_when_operand ? get_new_rex_input(*new_rex_idx_for_when_operand)
2174 : visit(when_operand),
2175 new_rex_idx_for_then_operand ? get_new_rex_input(*new_rex_idx_for_then_operand)
2176 : visit(then_operand));
2178 auto new_rex_idx_for_else_operand =
2179 is_collected_window_function(rex_case->
getElse()->
toHash());
2180 auto new_else = new_rex_idx_for_else_operand
2181 ? get_new_rex_input(*new_rex_idx_for_else_operand)
2183 return std::make_unique<RexCase>(new_pair_list, new_else);
2188 auto rex_it = window_func_to_new_rex_input_idx_map_.find(rex_hash);
2189 if (rex_it != window_func_to_new_rex_input_idx_map_.end()) {
2190 return rex_it->second;
2192 return std::nullopt;
2197 CHECK_LT(rex_idx, new_rex_input_for_window_func_.size());
2198 auto& new_rex_input = new_rex_input_for_window_func_.at(rex_idx);
2199 CHECK(new_rex_input);
2200 auto copied_rex_input = copier_.visit(new_rex_input.get());
2201 return copied_rex_input;
2210 std::unordered_map<size_t, std::unique_ptr<const RexInput>>&
2216 std::shared_ptr<RelProject> prev_node,
2217 std::shared_ptr<RelProject> new_node,
2218 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2220 auto delivered_hints = prev_node->getDeliveredHints();
2221 bool needs_propagate_hints = !delivered_hints->empty();
2222 if (needs_propagate_hints) {
2223 for (
auto& kv : *delivered_hints) {
2224 new_node->addHint(kv.second);
2226 auto prev_it = query_hints.find(prev_node->toHash());
2228 CHECK(prev_it != query_hints.end());
2229 auto prev_hint_it = prev_it->second.find(prev_node->getId());
2230 CHECK(prev_hint_it != prev_it->second.end());
2231 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2232 hint_map.emplace(new_node->getId(), prev_hint_it->second);
2233 query_hints.emplace(new_node->toHash(), hint_map);
2260 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
2261 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2263 std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
2264 for (
auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
2265 const auto node = *node_itr;
2266 auto window_func_project_node = std::dynamic_pointer_cast<
RelProject>(node);
2267 if (!window_func_project_node) {
2271 const auto prev_node_itr = std::prev(node_itr);
2272 const auto prev_node = *prev_node_itr;
2276 std::unordered_map<size_t, const RexScalar*> collected_window_func;
2280 for (
size_t i = 0; i < window_func_project_node->size(); i++) {
2281 const auto scalar_rex = window_func_project_node->getProjectAt(i);
2286 collector.
visit(scalar_rex);
2289 if (!collected_window_func.empty()) {
2291 std::unordered_set<size_t> collected_window_func_hash;
2294 std::vector<std::unique_ptr<const RexScalar>> new_rex_input_for_window_func;
2296 std::vector<std::unique_ptr<const RexScalar>> new_scalar_expr_for_window_project;
2299 std::unordered_map<size_t, size_t> window_func_to_new_rex_input_idx_map;
2303 std::unordered_map<size_t, std::unique_ptr<const RexInput>>
2304 new_rex_input_from_child_node;
2307 std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
2308 std::vector<std::string> dummy_fields;
2309 std::vector<std::string> new_project_field_names;
2312 std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);
2315 node_list.insert(node_itr, new_project);
2319 std::for_each(collected_window_func.begin(),
2320 collected_window_func.end(),
2321 [&new_project_field_names,
2322 &collected_window_func_hash,
2323 &new_rex_input_for_window_func,
2324 &new_scalar_expr_for_window_project,
2327 &window_func_to_new_rex_input_idx_map](
const auto& kv) {
2330 collected_window_func_hash.insert(kv.first);
2334 const auto rex_idx = new_rex_input_for_window_func.size();
2335 window_func_to_new_rex_input_idx_map.emplace(kv.first, rex_idx);
2339 new_rex_input_for_window_func.emplace_back(
2340 std::make_unique<const RexInput>(new_project.get(), rex_idx));
2341 new_scalar_expr_for_window_project.push_back(
2342 std::move(copier.visit(kv.second)));
2343 new_project_field_names.emplace_back(
"");
2345 new_project->setExpressions(new_scalar_expr_for_window_project);
2346 new_project->setFields(std::move(new_project_field_names));
2348 auto window_func_scalar_exprs =
2349 window_func_project_node->getExpressionsAndRelease();
2351 new_rex_input_for_window_func,
2352 window_func_to_new_rex_input_idx_map,
2354 new_rex_input_from_child_node);
2356 for (
auto& scalar_expr : window_func_scalar_exprs) {
2359 auto new_parent_rex = replacer.
visit(scalar_expr.get());
2360 window_func_scalar_exprs[rex_idx] = std::move(new_parent_rex);
2364 window_func_project_node->setExpressions(window_func_scalar_exprs);
2365 window_func_project_node->replaceInput(prev_node, new_project);
2369 nodes.assign(node_list.begin(), node_list.end());
2384 result.insert(next_result.begin(), next_result.end());
2402 std::vector<std::shared_ptr<RelAlgNode>>& nodes,
2403 const bool always_add_project_if_first_project_is_window_expr,
2404 std::unordered_map<
size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2406 std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
2407 size_t project_node_counter{0};
2408 for (
auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
2409 const auto node = *node_itr;
2411 auto window_func_project_node = std::dynamic_pointer_cast<
RelProject>(node);
2412 if (!window_func_project_node) {
2415 project_node_counter++;
2416 if (!window_func_project_node->hasWindowFunctionExpr()) {
2422 auto need_pushdown_generic_expr = [&window_func_project_node]() {
2423 for (
size_t i = 0; i < window_func_project_node->size(); ++i) {
2424 const auto projected_target = window_func_project_node->
getProjectAt(i);
2425 if (
auto window_expr =
2426 dynamic_cast<const RexWindowFunctionOperator*>(projected_target)) {
2427 for (
const auto& partition_key : window_expr->getPartitionKeys()) {
2428 auto partition_input =
dynamic_cast<const RexInput*
>(partition_key.get());
2429 if (!partition_input) {
2433 for (
const auto& order_key : window_expr->getOrderKeys()) {
2434 auto order_input =
dynamic_cast<const RexInput*
>(order_key.get());
2444 const auto prev_node_itr = std::prev(node_itr);
2445 const auto prev_node = *prev_node_itr;
2448 auto filter_node = std::dynamic_pointer_cast<
RelFilter>(prev_node);
2449 auto join_node = std::dynamic_pointer_cast<
RelJoin>(prev_node);
2451 auto scan_node = std::dynamic_pointer_cast<
RelScan>(prev_node);
2452 const bool has_multi_fragment_scan_input =
2454 (scan_node->getNumShards() > 0 || scan_node->getNumFragments() > 1));
2455 const bool needs_expr_pushdown = need_pushdown_generic_expr();
2480 if (!((always_add_project_if_first_project_is_window_expr &&
2481 project_node_counter == 1) ||
2482 filter_node || join_node || has_multi_fragment_scan_input ||
2483 needs_expr_pushdown)) {
2487 if (needs_expr_pushdown || join_node) {
2491 std::unordered_map<size_t, size_t> expr_offset_cache;
2492 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_new_project;
2493 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_window_project;
2494 std::vector<std::string> fields_for_window_project;
2495 std::vector<std::string> fields_for_new_project;
2498 std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
2499 std::vector<std::string> dummy_fields;
2501 std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);
2505 scalar_exprs_for_new_project,
2506 fields_for_new_project,
2508 for (
size_t i = 0; i < window_func_project_node->size(); ++i) {
2509 auto projected_target = window_func_project_node->getProjectAt(i);
2510 auto new_projection_target = visitor.visit(projected_target);
2511 scalar_exprs_for_window_project.emplace_back(
2512 std::move(new_projection_target.release()));
2514 new_project->setExpressions(scalar_exprs_for_new_project);
2515 new_project->setFields(std::move(fields_for_new_project));
2516 bool has_groupby =
false;
2517 auto aggregate = std::dynamic_pointer_cast<
RelAggregate>(prev_node);
2521 if (has_groupby && visitor.hasPartitionExpression()) {
2529 <<
"Query output overridden to row-wise format due to presence of a window "
2530 "function with partition expression and group-by expression.";
2531 new_project->forceRowwiseOutput();
2533 if (visitor.hasCaseExprAsWindowOperand()) {
2536 <<
"Query output overridden to row-wise format due to presence of a window "
2537 "function with a case statement as its operand.";
2538 new_project->forceRowwiseOutput();
2543 node_list.insert(node_itr, new_project);
2544 window_func_project_node->replaceInput(prev_node, new_project);
2545 window_func_project_node->setExpressions(scalar_exprs_for_window_project);
2550 for (
size_t i = 0; i < window_func_project_node->size(); i++) {
2552 input_collector.
visit(window_func_project_node->getProjectAt(i));
2553 inputs.insert(new_inputs.begin(), new_inputs.end());
2558 std::vector<RexInput> sorted_inputs(inputs.begin(), inputs.end());
2560 sorted_inputs.end(),
2561 [](
const auto&
a,
const auto& b) {
return a.getIndex() < b.getIndex(); });
2563 std::vector<std::unique_ptr<const RexScalar>> scalar_exprs;
2564 std::vector<std::string> fields;
2565 std::unordered_map<unsigned, unsigned> old_index_to_new_index;
2566 for (
auto& input : sorted_inputs) {
2567 CHECK_EQ(input.getSourceNode(), prev_node.get());
2568 CHECK(old_index_to_new_index
2569 .insert(std::make_pair(input.getIndex(), scalar_exprs.size()))
2571 scalar_exprs.emplace_back(input.deepCopy());
2572 fields.emplace_back(
"");
2575 auto new_project = std::make_shared<RelProject>(scalar_exprs, fields, prev_node);
2577 node_list.insert(node_itr, new_project);
2578 window_func_project_node->replaceInput(
2579 prev_node, new_project, old_index_to_new_index);
2582 nodes.assign(node_list.begin(), node_list.end());
2587 const int64_t default_val) noexcept {
2588 const auto it = obj.FindMember(
field);
2589 if (it == obj.MemberEnd()) {
2594 CHECK_EQ(
unsigned(0), lit->getScale());
2595 CHECK_EQ(
unsigned(0), lit->getTargetScale());
2596 return lit->getVal<int64_t>();
2600 const auto& inputs_json =
field(node,
"inputs");
2601 CHECK(inputs_json.IsArray() && !inputs_json.Size());
2605 const rapidjson::Value& scan_ra) {
2606 const auto& table_json =
field(scan_ra,
"table");
2607 CHECK(table_json.IsArray());
2608 CHECK_EQ(
unsigned(2), table_json.Size());
2615 const auto& fields_json =
field(scan_ra,
"fieldNames");
2635 std::vector<std::shared_ptr<RelAlgNode>>
run(
const rapidjson::Value& rels,
2637 for (
auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
2638 const auto& crt_node = *rels_it;
2639 const auto id =
node_id(crt_node);
2641 CHECK(crt_node.IsObject());
2642 std::shared_ptr<RelAlgNode> ra_node =
nullptr;
2644 if (rel_op == std::string(
"EnumerableTableScan") ||
2645 rel_op == std::string(
"LogicalTableScan")) {
2647 }
else if (rel_op == std::string(
"LogicalProject")) {
2649 }
else if (rel_op == std::string(
"LogicalFilter")) {
2651 }
else if (rel_op == std::string(
"LogicalAggregate")) {
2653 }
else if (rel_op == std::string(
"LogicalJoin")) {
2655 }
else if (rel_op == std::string(
"LogicalSort")) {
2657 }
else if (rel_op == std::string(
"LogicalValues")) {
2659 }
else if (rel_op == std::string(
"LogicalTableModify")) {
2661 }
else if (rel_op == std::string(
"LogicalTableFunctionScan")) {
2663 }
else if (rel_op == std::string(
"LogicalUnion")) {
2668 nodes_.push_back(ra_node);
2671 return std::move(
nodes_);
2677 CHECK(scan_ra.IsObject());
2680 if (scan_ra.HasMember(
"hints")) {
2681 auto scan_node = std::make_shared<RelScan>(td, field_names);
2685 return std::make_shared<RelScan>(td, field_names);
2691 CHECK_EQ(
size_t(1), inputs.size());
2692 const auto& exprs_json =
field(proj_ra,
"exprs");
2693 CHECK(exprs_json.IsArray());
2694 std::vector<std::unique_ptr<const RexScalar>> exprs;
2695 for (
auto exprs_json_it = exprs_json.Begin(); exprs_json_it != exprs_json.End();
2699 const auto& fields =
field(proj_ra,
"fields");
2700 if (proj_ra.HasMember(
"hints")) {
2701 auto project_node = std::make_shared<RelProject>(
2704 return project_node;
2706 return std::make_shared<RelProject>(
2713 CHECK_EQ(
size_t(1), inputs.size());
2714 const auto id =
node_id(filter_ra);
2718 return std::make_shared<RelFilter>(condition, inputs.front());
2723 CHECK_EQ(
size_t(1), inputs.size());
2726 for (
size_t i = 0; i < group.size(); ++i) {
2729 if (agg_ra.HasMember(
"groups") || agg_ra.HasMember(
"indicator")) {
2732 const auto& aggs_json_arr =
field(agg_ra,
"aggs");
2733 CHECK(aggs_json_arr.IsArray());
2734 std::vector<std::unique_ptr<const RexAgg>> aggs;
2735 for (
auto aggs_json_arr_it = aggs_json_arr.Begin();
2736 aggs_json_arr_it != aggs_json_arr.End();
2737 ++aggs_json_arr_it) {
2740 if (agg_ra.HasMember(
"hints")) {
2742 std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
2746 return std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
2752 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());
2875 table_func_inputs.emplace_back(
2879 const auto& op_name =
field(invocation,
"op");
2880 CHECK(op_name.IsString());
2882 std::vector<std::unique_ptr<const RexScalar>> table_function_projected_outputs;
2883 const auto& row_types =
field(table_func_ra,
"rowType");
2884 CHECK(row_types.IsArray());
2885 CHECK_GE(row_types.Size(), unsigned(0));
2886 const auto& row_types_array = row_types.GetArray();
2887 for (
size_t i = 0; i < row_types_array.Size(); i++) {
2890 table_function_projected_outputs.emplace_back(std::make_unique<RexRef>(i));
2891 fields.emplace_back(
"");
2893 return std::make_shared<RelTableFunction>(op_name.GetString(),
2898 table_function_projected_outputs);
2902 const rapidjson::Value& logical_values_ra) {
2903 const auto& tuple_type_arr =
field(logical_values_ra,
"type");
2904 CHECK(tuple_type_arr.IsArray());
2905 std::vector<TargetMetaInfo> tuple_type;
2906 for (
auto tuple_type_arr_it = tuple_type_arr.Begin();
2907 tuple_type_arr_it != tuple_type_arr.End();
2908 ++tuple_type_arr_it) {
2909 const auto component_type =
parse_type(*tuple_type_arr_it);
2910 const auto component_name =
json_str(
field(*tuple_type_arr_it,
"name"));
2911 tuple_type.emplace_back(component_name, component_type);
2913 const auto& inputs_arr =
field(logical_values_ra,
"inputs");
2914 CHECK(inputs_arr.IsArray());
2915 const auto& tuples_arr =
field(logical_values_ra,
"tuples");
2916 CHECK(tuples_arr.IsArray());
2918 if (inputs_arr.Size()) {
2922 std::vector<RelLogicalValues::RowValues> values;
2923 if (tuples_arr.Size()) {
2924 for (
const auto& row : tuples_arr.GetArray()) {
2925 CHECK(row.IsArray());
2926 const auto values_json = row.GetArray();
2927 if (!values.empty()) {
2928 CHECK_EQ(values[0].size(), values_json.Size());
2931 for (
const auto& value : values_json) {
2932 CHECK(value.IsObject());
2933 CHECK(value.HasMember(
"literal"));
2939 return std::make_shared<RelLogicalValues>(tuple_type, values);
2943 const rapidjson::Value& logical_union_ra) {
2945 auto const& all_type_bool =
field(logical_union_ra,
"all");
2946 CHECK(all_type_bool.IsBool());
2947 return std::make_shared<RelLogicalUnion>(std::move(inputs), all_type_bool.GetBool());
2951 if (node.HasMember(
"inputs")) {
2954 for (
const auto& str_id : str_input_ids) {
2955 ra_inputs.push_back(
nodes_[std::stoi(str_id)]);
2959 return {
prev(node)};
2963 auto option = str.substr(0, pos);
2964 std::string delim =
"=";
2965 size_t delim_pos = option.find(delim);
2966 auto key = option.substr(0, delim_pos);
2967 auto val = option.substr(delim_pos + 1, option.length());
2968 str.erase(0, pos + delim.length() + 1);
2973 std::string white_space_delim =
" ";
2974 int l = hint_string.length();
2975 hint_string = hint_string.erase(0, 1).substr(0, l - 2);
2977 auto global_hint_checker = [&](
const std::string& input_hint_name) ->
HintIdentifier {
2978 bool global_hint =
false;
2979 std::string hint_name = input_hint_name;
2980 auto global_hint_identifier = hint_name.substr(0, 2);
2981 if (global_hint_identifier.compare(
"g_") == 0) {
2983 hint_name = hint_name.substr(2, hint_string.length());
2985 return {global_hint, hint_name};
2988 global_hint_checker(hint_string.substr(0, hint_string.find(white_space_delim)));
2990 if ((pos = hint_string.find(
"options:")) != std::string::npos) {
2992 std::vector<std::string> tokens;
2993 bool kv_list_op =
false;
2994 std::string raw_options = hint_string.substr(pos + 8, hint_string.length() - 2);
2995 if (raw_options.find(
'{') != std::string::npos) {
2998 CHECK(raw_options.find(
'[') != std::string::npos);
3000 auto t1 = raw_options.erase(0, 1);
3001 raw_options = t1.substr(0, t1.length() - 1);
3002 std::string op_delim =
", ";
3005 std::unordered_map<std::string, std::string> kv_options;
3006 while ((pos = raw_options.find(op_delim)) != std::string::npos) {
3008 kv_options.emplace(kv_pair.first, kv_pair.second);
3012 kv_options.emplace(kv_pair.first, kv_pair.second);
3013 return {hint_type, parsed_hint.global_hint,
false,
true, kv_options};
3015 std::vector<std::string> list_options;
3016 while ((pos = raw_options.find(op_delim)) != std::string::npos) {
3017 list_options.emplace_back(raw_options.substr(0, pos));
3018 raw_options.erase(0, pos + white_space_delim.length() + 1);
3021 list_options.emplace_back(raw_options.substr(0, pos));
3022 return {hint_type, parsed_hint.global_hint,
false,
false, list_options};
3026 return {hint_type, parsed_hint.global_hint,
true,
false};
3031 std::shared_ptr<RelAlgNode> node) {
3032 std::string hint_explained =
json_str(
field(json_node,
"hints"));
3034 std::string delim =
"|";
3035 std::vector<std::string> hint_list;
3036 while ((pos = hint_explained.find(delim)) != std::string::npos) {
3037 hint_list.emplace_back(hint_explained.substr(0, pos));
3038 hint_explained.erase(0, pos + delim.length());
3041 hint_list.emplace_back(hint_explained.substr(0, pos));
3043 const auto agg_node = std::dynamic_pointer_cast<
RelAggregate>(node);
3045 for (std::string& hint : hint_list) {
3047 agg_node->addHint(parsed_hint);
3050 const auto project_node = std::dynamic_pointer_cast<
RelProject>(node);
3052 for (std::string& hint : hint_list) {
3054 project_node->addHint(parsed_hint);
3057 const auto scan_node = std::dynamic_pointer_cast<
RelScan>(node);
3059 for (std::string& hint : hint_list) {
3061 scan_node->addHint(parsed_hint);
3064 const auto join_node = std::dynamic_pointer_cast<
RelJoin>(node);
3066 for (std::string& hint : hint_list) {
3068 join_node->addHint(parsed_hint);
3072 const auto compound_node = std::dynamic_pointer_cast<
RelCompound>(node);
3073 if (compound_node) {
3074 for (std::string& hint : hint_list) {
3076 compound_node->addHint(parsed_hint);
3081 std::shared_ptr<const RelAlgNode>
prev(
const rapidjson::Value& crt_node) {
3082 const auto id =
node_id(crt_node);
3089 std::vector<std::shared_ptr<RelAlgNode>>
nodes_;
3097 : cat_(cat), render_info_(render_info) {
3098 rapidjson::Document query_ast;
3099 query_ast.Parse(query_ra.c_str());
3100 VLOG(2) <<
"Parsing query RA JSON: " << query_ra;
3101 if (query_ast.HasParseError()) {
3102 query_ast.GetParseError();
3103 LOG(
ERROR) <<
"Failed to parse RA tree from Calcite (offset "
3104 << query_ast.GetErrorOffset() <<
"):\n"
3105 << rapidjson::GetParseError_En(query_ast.GetParseError());
3106 VLOG(1) <<
"Failed to parse query RA: " << query_ra;
3107 throw std::runtime_error(
3108 "Failed to parse relational algebra tree. Possible query syntax error.");
3110 CHECK(query_ast.IsObject());
3112 build(query_ast, *
this);
3116 const rapidjson::Value& query_ast,
3119 : cat_(cat), render_info_(render_info) {
3120 build(query_ast, root_dag_builder);
3125 const auto& rels =
field(query_ast,
"rels");
3126 CHECK(rels.IsArray());
3148 std::vector<const RelAlgNode*> filtered_left_deep_joins;
3149 std::vector<const RelAlgNode*> left_deep_joins;
3150 for (
const auto& node :
nodes_) {
3154 if (left_deep_join_root) {
3155 left_deep_joins.push_back(left_deep_join_root.get());
3156 if (std::dynamic_pointer_cast<const RelFilter>(left_deep_join_root)) {
3157 filtered_left_deep_joins.push_back(left_deep_join_root.get());
3161 if (filtered_left_deep_joins.empty()) {
3172 CHECK(nodes_.back().use_count() == 1);
3177 std::function<
void(
RelAlgNode const*)>
const& callback)
const {
3178 for (
auto const& node :
nodes_) {
3180 callback(node.get());
3186 for (
auto& node :
nodes_) {
3188 node->resetQueryExecutionState();
3196 for (
size_t i = 0; i < ra->
inputCount(); ++i) {
3203 return cat(::
typeName(
this),
"(", ra_->toString(config),
")");
3208 hash_ =
typeid(RexSubQuery).hash_code();
3209 boost::hash_combine(*hash_, ra_->toHash());
3215 const auto scan_node =
dynamic_cast<const RelScan*
>(
node_);
3218 auto table_name = scan_node->getTableDescriptor()->tableName;
3244 ret += expr->toString(config) +
" ";
3246 ret +=
", agg_exps=";
3248 ret += expr->toString(config) +
" ";
3250 ret +=
", scalar_sources=";
3252 ret += expr->toString(config) +
" ";
3270 if (
auto rex_scalar = dynamic_cast<const RexScalar*>(target_expr)) {
3271 boost::hash_combine(*
hash_, rex_scalar->toHash());
3275 boost::hash_combine(*
hash_, agg_expr->toHash());
3278 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::shared_ptr< const RelAlgNode > getRootNodeShPtr() const
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)
bool is_agg(const Analyzer::Expr *expr)
bool is_window_function_operator(const RexScalar *rex)
std::unique_ptr< const RexScalar > condition_
SQLTypeInfo parse_type(const rapidjson::Value &type_obj)
const RexScalar * getThen(const size_t idx) const
std::vector< std::string > strings_from_json_array(const rapidjson::Value &json_str_arr) noexcept
std::unique_ptr< RexCase > parse_case(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
std::shared_ptr< RelAggregate > dispatchAggregate(const rapidjson::Value &agg_ra)
std::shared_ptr< RelAlgNode > ElementType
std::vector< std::unique_ptr< const RexScalar > > & scalar_exprs_for_new_project_
JoinType to_join_type(const std::string &join_type_name)
const Catalog_Namespace::Catalog & cat_
std::shared_ptr< RelProject > dispatchProject(const rapidjson::Value &proj_ra, RelAlgDagBuilder &root_dag_builder)
std::unique_ptr< const RexScalar > visitOperator(const RexOperator *rex_operator) const override
std::unique_ptr< RexSubQuery > deepCopy() const
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
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::vector< std::unique_ptr< const RexScalar > > table_func_inputs_
void bind_inputs(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
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::unique_ptr< const RexScalar > visitRef(const RexRef *rex_ref) const override
void addHint(const ExplainedQueryHint &hint_explained)
std::shared_ptr< const RelAlgNode > get_left_deep_join_root(const std::shared_ptr< RelAlgNode > &node)
void * visitCase(const RexCase *rex_case) const final
void sink_projected_boolean_expr_to_join(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::unique_ptr< const RexAgg > parse_aggregate_expr(const rapidjson::Value &expr)
const unsigned FIRST_RA_NODE_ID
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
void eliminate_identical_copy(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
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())
RetType visitInput(const RexInput *input) const final
static thread_local unsigned crt_id_
void compute_node_hash(const std::vector< std::shared_ptr< RelAlgNode >> &nodes)
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
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
size_t pushDownExpressionImpl(const RexScalar *expr) const
SQLAgg to_agg_kind(const std::string &agg_name)
std::shared_ptr< RelLogicalUnion > dispatchUnion(const rapidjson::Value &logical_union_ra)
const RelAlgNode * node_to_keep_
std::vector< std::string > TargetColumnList
const SQLTypeInfo & getType() const
void * visitOperator(const RexOperator *rex_operator) const final
Hints * getDeliveredHints()
const bool json_bool(const rapidjson::Value &obj) noexcept
const RexScalar * getOperand(const size_t idx) const
std::vector< const Rex * > col_inputs_
std::unordered_map< size_t, size_t > & window_func_to_new_rex_input_idx_map_
bool hasEquivCollationOf(const RelSort &that) const
bool is_window_function_sum(const RexScalar *rex)
const std::string json_str(const rapidjson::Value &obj) noexcept
RelProject * new_project_
void build(const rapidjson::Value &query_ast, RelAlgDagBuilder &root_dag_builder)
std::shared_ptr< RelProject > new_project_
RexWindowFunctionOperator::RexWindowBound parse_window_bound(const rapidjson::Value &window_bound_obj, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
void bind_table_func_to_input(RelTableFunction *table_func_node, const RANodeOutput &input) noexcept
std::unique_ptr< RexOperator > parse_operator(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
DEVICE void sort(ARGS &&...args)
bool isRenamedInput(const RelAlgNode *node, const size_t index, const std::string &new_name)
std::optional< size_t > getIdInPlanTree() const
std::vector< std::string > fields_
void addHint(const ExplainedQueryHint &hint_explained)
const RexScalar * getWhen(const size_t idx) const
std::unordered_map< size_t, size_t > pushed_down_order_key_offset_
void appendInput(std::string new_field_name, std::unique_ptr< const RexScalar > new_input)
void * defaultResult() const final
RetType visitOperator(const RexOperator *rex_operator) const final
void addHint(const ExplainedQueryHint &hint_explained)
void bind_project_to_input(RelProject *project_node, const RANodeOutput &input) noexcept
const Catalog_Namespace::Catalog & cat_
bool visitInput(const RexInput *input) const final
std::vector< std::unique_ptr< const RexScalar > > parse_window_order_exprs(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
void handle_query_hint(const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDagBuilder *dag_builder) noexcept
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
void checkForMatchingMetaInfoTypes() const
std::unordered_set< size_t > & collected_window_func_hash_
std::vector< std::unique_ptr< const RexScalar > > scalar_sources_
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)
SqlWindowFunctionKind parse_window_function_kind(const std::string &name)
const std::string getFieldName(const size_t i) const
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
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)
void simplify_sort(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::vector< SortField > collation_
int64_t get_int_literal_field(const rapidjson::Value &obj, const char field[], const int64_t default_val) noexcept
std::unique_ptr< const RexScalar > visitSubQuery(const RexSubQuery *rex_subquery) const override
std::vector< std::unique_ptr< const RexScalar > > parse_expr_array(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
This file contains the class specification and related data structures for Catalog.
virtual T visit(const RexScalar *rex_scalar) const
std::vector< std::shared_ptr< RexSubQuery > > subqueries_
const RenderInfo * render_info_
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
bool hasPartitionExpression()
SQLOps getOperator() const
std::vector< std::shared_ptr< RelAlgNode > > nodes_
bool aggregateResult(const bool &aggregate, const bool &next_result) const final
const TableDescriptor * getTableFromScanNode(const Catalog_Namespace::Catalog &cat, const rapidjson::Value &scan_ra)
SortDirection parse_sort_direction(const rapidjson::Value &collation)
std::unordered_set< size_t > visited_
std::unique_ptr< const RexScalar > get_new_rex_input(size_t rex_idx) const
std::optional< size_t > getOffsetForPushedDownExpr(WindowExprType type, size_t expr_offset) const
std::unique_ptr< const RexScalar > disambiguate_rex(const RexScalar *, const RANodeOutput &)
static QueryHint translateQueryHint(const std::string &hint_name)
DEVICE auto copy(ARGS &&...args)
void resetQueryExecutionState()
std::vector< SortField > parse_window_order_collation(const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
Hints * getDeliveredHints()
size_t toHash() const override
std::vector< std::string > fields_
SQLOps to_sql_op(const std::string &op_str)
std::unique_ptr< Hints > hints_
RexDeepCopyVisitor deep_copier_
const int64_t json_i64(const rapidjson::Value &obj) noexcept
bool visitSubQuery(const RexSubQuery *) const final
std::unique_ptr< Hints > hints_
bool hasCaseExprAsWindowOperand()
std::vector< std::unique_ptr< const RexScalar > > scalar_exprs_
const double json_double(const rapidjson::Value &obj) noexcept
void addHint(const ExplainedQueryHint &hint_explained)
size_t branchCount() const
std::unordered_set< RexInput > RexInputSet
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)
const RelAlgNode * getInput(const size_t idx) const
RelFilter(std::unique_ptr< const RexScalar > &filter, std::shared_ptr< const RelAlgNode > input)
const ElementType & operator*()
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_
RexInputReplacementVisitor(const RelAlgNode *node_to_keep, const std::vector< std::unique_ptr< const RexScalar >> &scalar_sources)
std::optional< size_t > hash_
const size_t groupby_count_
std::optional< size_t > hash_
std::unordered_map< size_t, const RexScalar * > & collected_window_func_
std::string toString(const Executor::ExtModuleKinds &kind)
virtual void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input)
void eachNode(std::function< void(RelAlgNode const *)> const &) const
std::unordered_map< size_t, std::unique_ptr< const RexInput > > & new_rex_input_from_child_node_
NullSortedPosition parse_nulls_position(const rapidjson::Value &collation)
std::shared_ptr< RelFilter > dispatchFilter(const rapidjson::Value &filter_ra, RelAlgDagBuilder &root_dag_builder)
std::unique_ptr< RexAbstractInput > parse_abstract_input(const rapidjson::Value &expr) noexcept
std::unique_ptr< const RexScalar > visitCase(const RexCase *rex_case) const override
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
std::vector< std::string > & fields_for_new_project_
std::set< std::pair< const RelAlgNode *, int > > get_equiv_cols(const RelAlgNode *node, const size_t which_col)
Hints * getDeliveredHints()
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::unique_ptr< RexLiteral > parse_literal(const rapidjson::Value &expr)
size_t toHash() const override
const RexScalar * getProjectAt(const size_t idx) const
std::vector< std::unique_ptr< const RexAgg > > copyAggExprs(std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs)
std::vector< std::shared_ptr< const RelAlgNode >> RelAlgInputs
std::vector< ElementType > Container
static RegisteredQueryHint defaults()
void advance(AdvancingMode mode)
int32_t countRexLiteralArgs() const
std::unique_ptr< Hints > hints_
std::unique_ptr< const RexOperator > disambiguate_operator(const RexOperator *rex_operator, const RANodeOutput &ra_output) noexcept
const ConstRexScalarPtrVector & getPartitionKeys() const
std::string tree_string(const RelAlgNode *ra, const size_t depth)
DEVICE auto lower_bound(ARGS &&...args)
RexDeepCopyVisitor copier_
std::unique_ptr< Hints > hints_
const std::vector< const Rex * > target_exprs_
std::vector< ElementType >::const_iterator Super
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
RelLogicalUnion(RelAlgInputs, bool is_all)
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
std::unique_ptr< const RexCase > disambiguate_case(const RexCase *rex_case, const RANodeOutput &ra_output)
std::shared_ptr< RelJoin > dispatchJoin(const rapidjson::Value &join_ra, RelAlgDagBuilder &root_dag_builder)
std::unique_ptr< const RexScalar > filter_expr_
bool hasWindowFunctionExpr() const
std::shared_ptr< RelModify > dispatchModify(const rapidjson::Value &logical_modify_ra)
const std::vector< std::unique_ptr< const RexScalar > > & scalar_sources_
std::unordered_map< QueryHint, ExplainedQueryHint > Hints
virtual size_t size() const =0
void registerSubquery(std::shared_ptr< RexSubQuery > subquery)
void setExecutionResult(const std::shared_ptr< const ExecutionResult > result)
std::unordered_map< size_t, size_t > & expr_offset_cache_
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
const ElementType * operator->()
std::unique_ptr< const RexScalar > visitLiteral(const RexLiteral *rex_literal) const override
std::string typeName(const T *v)
ExplainedQueryHint parseHintString(std::string &hint_string)
RelAlgDagBuilder()=delete
WindowFunctionCollector(std::unordered_map< size_t, const RexScalar * > &collected_window_func)
void mark_nops(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::shared_ptr< RelSort > dispatchSort(const rapidjson::Value &sort_ra)
void separate_window_function_expressions(std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
bool defaultResult() const final
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)
bool visitRef(const RexRef *) const final
const std::vector< std::string > & getFields() const
std::unordered_map< size_t, size_t > pushed_down_window_operands_offset_
std::string getFieldName(const size_t i) const
std::vector< size_t > indices_from_json_array(const rapidjson::Value &json_idx_arr) noexcept
std::unordered_map< size_t, size_t > pushed_down_partition_key_offset_
bool g_enable_watchdog false
std::unique_ptr< const RexScalar > parse_scalar_expr(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
const ConstRexScalarPtrVector & getOrderKeys() const
RelProject(std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs, const std::vector< std::string > &fields, std::shared_ptr< const RelAlgNode > input)
unsigned node_id(const rapidjson::Value &ra_node) noexcept
RANodeOutput get_node_output(const RelAlgNode *ra_node)
std::unique_ptr< const RexScalar > defaultResult() const override
bool is_window_function_avg(const RexScalar *rex)
std::vector< std::string > getFieldNamesFromScanNode(const rapidjson::Value &scan_ra)
void alterRAForRender(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const RenderInfo &render_info)
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
bool visitLiteral(const RexLiteral *) const final
std::vector< std::shared_ptr< RelAlgNode > > run(const rapidjson::Value &rels, RelAlgDagBuilder &root_dag_builder)
void getRelAlgHints(const rapidjson::Value &json_node, std::shared_ptr< RelAlgNode > node)
virtual size_t toHash() const =0
RelAlgDispatcher(const Catalog_Namespace::Catalog &cat)
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)
RetType visitCase(const RexCase *rex_case) const final
Common Enum definitions for SQL processing.
bool is_dict_encoded_string() const
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< RexInput > RANodeOutput
void pushDownExpressionInWindowFunction(const RexWindowFunctionOperator *window_expr) const
std::vector< std::unique_ptr< const RexScalar >> RowValues
const size_t inputCount() const
void rebind_inputs_from_left_deep_join(const RexScalar *rex, const RelLeftDeepInnerJoin *left_deep_join)
std::unique_ptr< const RexSubQuery > parse_subquery(const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)
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
bool input_can_be_coalesced(const RelAlgNode *parent_node, const size_t index, const bool first_rex_is_input)
std::vector< std::unique_ptr< const RexScalar > > & new_rex_input_for_window_func_
RelAlgInputs getRelAlgInputs(const rapidjson::Value &node)
std::shared_ptr< RelLogicalValues > dispatchLogicalValues(const rapidjson::Value &logical_values_ra)
std::shared_ptr< RelTableFunction > dispatchTableFunction(const rapidjson::Value &table_func_ra, RelAlgDagBuilder &root_dag_builder)
DEVICE void swap(ARGS &&...args)
std::unique_ptr< const RexScalar > RetType
std::vector< std::unique_ptr< const RexScalar > > copyRexScalars(std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources)
size_t toHash() const override
bool found_case_expr_window_operand_
virtual size_t toHash() const =0
std::optional< size_t > is_collected_window_function(size_t rex_hash) const
RelJoin(std::shared_ptr< const RelAlgNode > lhs, std::shared_ptr< const RelAlgNode > rhs, std::unique_ptr< const RexScalar > &condition, const JoinType join_type)
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
void check_empty_inputs_field(const rapidjson::Value &node) noexcept
std::vector< const Rex * > reproject_targets(const RelProject *simple_project, const std::vector< const Rex * > &target_exprs) noexcept
std::vector< std::unique_ptr< const RexScalar > > target_exprs_
std::vector< RexInput > n_outputs(const RelAlgNode *node, const size_t n)
std::unique_ptr< const RexScalar > visitInput(const RexInput *rex_input) const override
static void resetRelAlgFirstId() noexcept
std::string json_node_to_string(const rapidjson::Value &node) noexcept
RetType visitInput(const RexInput *rex_input) const final