28 #include <unordered_map>
30 #include <rapidjson/document.h>
31 #include <boost/core/noncopyable.hpp>
32 #include <boost/functional/hash.hpp>
44 static auto const HASH_N = boost::hash_value(
"n");
57 virtual size_t toHash()
const = 0;
62 mutable std::optional<size_t>
hash_;
109 const unsigned scale,
110 const unsigned precision,
111 const unsigned target_scale,
112 const unsigned target_precision)
128 const unsigned scale,
129 const unsigned precision,
130 const unsigned target_scale,
131 const unsigned target_precision)
145 const unsigned scale,
146 const unsigned precision,
147 const unsigned target_scale,
148 const unsigned target_precision)
162 const unsigned scale,
163 const unsigned precision,
164 const unsigned target_scale,
165 const unsigned target_precision)
187 const auto ptr = boost::get<T>(&
literal_);
206 std::ostringstream oss;
216 boost::apply_visitor(
217 [
this](
auto&& current_val) {
218 using T = std::decay_t<decltype(current_val)>;
219 if constexpr (!std::is_same_v<boost::blank, T>) {
220 static_assert(std::is_same_v<int64_t, T> || std::is_same_v<double, T> ||
221 std::is_same_v<std::string, T> || std::is_same_v<bool, T>);
222 boost::hash_combine(*
hash_, current_val);
237 return std::make_unique<RexLiteral>(*this);
241 boost::variant<boost::blank, int64_t, double, std::string, bool>
literal_;
261 std::vector<std::unique_ptr<const RexScalar>>& operands,
266 std::vector<std::unique_ptr<const RexScalar>>& operands)
const {
290 ret += operand->toString(config) +
" ";
300 boost::hash_combine(*
hash_, operand->toHash());
309 mutable std::vector<std::unique_ptr<const RexScalar>>
operands_;
335 std::shared_ptr<ExecutionResultShPtr>
result,
336 const std::shared_ptr<const RelAlgNode> ra)
349 return *(
type_.get());
358 unsigned getId()
const;
365 size_t toHash()
const override;
367 std::unique_ptr<RexSubQuery>
deepCopy()
const;
373 std::shared_ptr<ExecutionResultShPtr>
result_;
374 std::shared_ptr<const RelAlgNode>
ra_;
403 size_t toHash()
const override;
431 RexCase(std::vector<std::pair<std::unique_ptr<const RexScalar>,
432 std::unique_ptr<const RexScalar>>>& expr_pair_list,
433 std::unique_ptr<const RexScalar>& else_expr)
452 auto ret =
cat(::
typeName(
this),
"(expr_pair_list=");
454 ret += expr.first->toString(config) +
" " + expr.second->toString(config) +
" ";
474 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
495 std::vector<std::unique_ptr<const RexScalar>>& operands)
const override {
496 return std::unique_ptr<const RexOperator>(
506 ret += operand->toString(config) +
" ";
508 return cat(ret,
")");
517 boost::hash_combine(*
hash_, operand->toHash());
564 auto hash = boost::hash_value(
field_);
611 const std::vector<SortField> collation,
640 std::unique_ptr<const RexScalar>&& new_partition_key) {
645 void replaceOrderKey(
size_t offset, std::unique_ptr<const RexScalar>&& new_order_key) {
666 const std::vector<SortField>& collation)
const {
667 return std::unique_ptr<const RexOperator>(
683 ret += operand->toString(config) +
" ";
685 ret +=
", partition_keys=";
687 ret += key->toString(config) +
" ";
689 ret +=
", order_keys=";
691 ret += key->toString(config) +
" ";
693 return cat(ret,
")");
703 boost::hash_combine(*
hash_, collation.toHash());
706 boost::hash_combine(*
hash_, operand->toHash());
709 boost::hash_combine(*
hash_, key->toHash());
712 boost::hash_combine(*
hash_, key->toHash());
714 auto get_window_bound_hash =
717 boost::hash_value(bound.bound_expr ? bound.bound_expr->toHash() :
HASH_N);
718 boost::hash_combine(h, bound.unbounded);
719 boost::hash_combine(h, bound.preceding);
720 boost::hash_combine(h, bound.following);
721 boost::hash_combine(h, bound.is_current_row);
722 boost::hash_combine(h, bound.order_key);
767 std::unique_ptr<RexRef>
deepCopy()
const {
return std::make_unique<RexRef>(
index_); }
783 const std::vector<size_t>& operands)
804 boost::hash_combine(*
hash_, operand);
866 if (!extracted_query_plan_dag.empty()) {
907 for (
auto& input_ptr :
inputs_) {
908 if (input_ptr.get() == needle) {
916 std::shared_ptr<const RelAlgNode> input) {
917 for (
auto& input_ptr :
inputs_) {
918 if (input_ptr == old_input) {
937 virtual size_t toHash()
const = 0;
939 virtual size_t size()
const = 0;
941 virtual std::shared_ptr<RelAlgNode>
deepCopy()
const = 0;
955 mutable std::optional<size_t>
hash_;
976 const std::vector<std::string>& field_names,
1014 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1057 bool const delete_via_select =
false,
1058 bool const varlen_update_required =
false,
1103 template <
typename VALIDATION_FUNCTOR>
1106 if (validator(column_name) ==
false) {
1138 RelProject(std::vector<std::unique_ptr<const RexScalar>>& scalar_exprs,
1139 const std::vector<std::string>& fields,
1140 std::shared_ptr<const RelAlgNode> input)
1161 if (!dynamic_cast<const RexInput*>(expr.get())) {
1175 std::shared_ptr<RelProject> new_project_node)
const {
1177 new_project_node->setUpdateViaSelectFlag(
true);
1180 new_project_node->setDeleteViaSelectFlag(
true);
1183 new_project_node->setVarlenUpdateRequired(
true);
1224 std::shared_ptr<const RelAlgNode> input)
override {
1229 std::shared_ptr<const RelAlgNode> old_input,
1230 std::shared_ptr<const RelAlgNode> input,
1231 std::optional<std::unordered_map<unsigned, unsigned>> old_to_new_index_map);
1234 std::unique_ptr<const RexScalar> new_input);
1240 ret += expr->toString(config) +
" ";
1249 boost::hash_combine(*
hash_, target_expr->toHash());
1256 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1257 auto copied_project_node = std::make_shared<RelProject>(*this);
1262 copied_project_node->setPushedDownWindowExpr();
1264 return copied_project_node;
1295 template <
typename EXPR_VISITOR_FUNCTOR>
1297 for (
int i = 0; i < static_cast<int>(
scalar_exprs_.size()); i++) {
1305 std::make_unique<RexFunctionOperator const>(std::string(
"OFFSET_IN_FRAGMENT"),
1308 fields_.emplace_back(
"EXPR$DELETE_OFFSET_IN_FRAGMENT");
1327 std::vector<std::unique_ptr<const RexAgg>>& agg_exprs,
1328 const std::vector<std::string>& fields,
1329 std::shared_ptr<const RelAlgNode> input)
1348 fields_ = std::move(new_fields);
1354 std::vector<const RexAgg*>
result;
1356 result.push_back(agg_expr.release());
1365 const std::vector<std::unique_ptr<const RexAgg>>&
getAggExprs()
const {
1369 void setAggExprs(std::vector<std::unique_ptr<const RexAgg>>& agg_exprs) {
1382 if (!config.skip_input_nodes) {
1385 ret +=
", input node id={";
1387 auto node_id_in_plan = input->getIdInPlanTree();
1388 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1390 ret += node_id_str +
" ";
1394 return cat(ret,
")");
1402 boost::hash_combine(*
hash_, agg_expr->toHash());
1405 boost::hash_combine(*
hash_, node->toHash());
1412 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1413 return std::make_shared<RelAggregate>(*this);
1457 std::shared_ptr<const RelAlgNode> rhs,
1458 std::unique_ptr<const RexScalar>& condition,
1481 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1482 std::shared_ptr<const RelAlgNode> input)
override;
1487 if (!config.skip_input_nodes) {
1490 ret +=
", input node id={";
1492 auto node_id_in_plan = input->getIdInPlanTree();
1493 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1495 ret += node_id_str +
" ";
1511 boost::hash_combine(*
hash_, node->toHash());
1520 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1521 return std::make_shared<RelJoin>(*this);
1564 const std::vector<const Analyzer::ColumnVar*> lhs_join_cols,
1565 const std::vector<const Analyzer::ColumnVar*> rhs_join_cols,
1566 const std::vector<std::shared_ptr<const Analyzer::Expr>> filter_ops,
1568 const bool nested_loop,
1570 const std::string& op_type,
1571 const std::string& qualifier,
1572 const std::string& op_typeinfo)
1588 "( join_quals { lhs: ",
1592 " }, filter_quals: { ",
1594 " }, outer_join_cond: { ",
1620 boost::hash_combine(*
hash_, filter_op->toString());
1628 const std::vector<std::shared_ptr<const Analyzer::Expr>>
getFilterCond()
const {
1635 size_t size()
const override {
return 0; }
1647 std::shared_ptr<const RelAlgNode> input)
override {
1650 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1683 std::shared_ptr<const RelAlgNode> input)
1684 :
filter_(std::move(filter)) {
1702 filter_ = std::move(condition);
1707 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1708 std::shared_ptr<const RelAlgNode> input)
override;
1714 if (!config.skip_input_nodes) {
1717 ret +=
", input node id={";
1719 auto node_id_in_plan = input->getIdInPlanTree();
1720 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1722 ret += node_id_str +
" ";
1726 return cat(ret,
")");
1734 boost::hash_combine(*
hash_, node->toHash());
1740 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1741 return std::make_shared<RelFilter>(*this);
1758 std::vector<std::shared_ptr<const RelJoin>>& original_joins);
1769 size_t toHash()
const override;
1771 size_t size()
const override;
1773 std::shared_ptr<RelAlgNode>
deepCopy()
const override;
1806 RelCompound(std::unique_ptr<const RexScalar>& filter_expr,
1807 const std::vector<const Rex*>& target_exprs,
1808 const size_t groupby_count,
1809 const std::vector<const RexAgg*>& agg_exprs,
1810 const std::vector<std::string>& fields,
1811 std::vector<std::unique_ptr<const RexScalar>>& scalar_sources,
1813 bool update_disguised_as_select =
false,
1814 bool delete_disguised_as_select =
false,
1815 bool varlen_update_required =
false,
1820 delete_disguised_as_select,
1821 varlen_update_required,
1822 manipulation_target_table,
1833 CHECK_EQ(fields.size(), target_exprs.size());
1834 for (
auto agg_expr : agg_exprs) {
1841 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1842 std::shared_ptr<const RelAlgNode> input)
override;
1882 size_t toHash()
const override;
1884 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1885 return std::make_shared<RelCompound>(*this);
1919 std::vector<std::unique_ptr<const RexScalar>>
1936 const size_t offset,
1937 std::shared_ptr<const RelAlgNode> input,
1938 bool limit_delivered)
1986 if (!config.skip_input_nodes) {
1989 ret +=
", input node id={";
1991 auto node_id_in_plan = input->getIdInPlanTree();
1992 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1994 ret += node_id_str +
" ";
1998 return cat(ret,
")");
2005 boost::hash_combine(*
hash_, collation.toHash());
2014 boost::hash_combine(*
hash_, node->toHash());
2022 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2023 return std::make_shared<RelSort>(*this);
2055 throw std::runtime_error(
"Unexpected ModifyOperation enum encountered.");
2059 if (op_string ==
"INSERT") {
2061 }
else if (op_string ==
"DELETE") {
2063 }
else if (op_string ==
"UPDATE") {
2067 throw std::runtime_error(
2068 std::string(
"Unsupported logical modify operation encountered " + op_string));
2081 std::string
const& op_string,
2117 size_t size()
const override {
return 0; }
2118 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2119 return std::make_shared<RelModify>(*this);
2131 ", target_column_list=",
2133 if (!config.skip_input_nodes) {
2136 ret +=
", input node id={";
2138 auto node_id_in_plan = input->getIdInPlanTree();
2139 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
2141 ret += node_id_str +
" ";
2145 return cat(ret,
")");
2156 boost::hash_combine(*
hash_, node->toHash());
2164 CHECK(previous_node !=
nullptr);
2165 auto previous_project_node =
const_cast<RelProject*
>(previous_node);
2167 if (previous_project_node->hasWindowFunctionExpr()) {
2169 throw std::runtime_error(
2170 "UPDATE of a column of multi-fragmented table using window function not "
2171 "currently supported.");
2174 throw std::runtime_error(
2175 "UPDATE of a column of sharded table using window function not "
2176 "currently supported.");
2180 previous_project_node->setUpdateViaSelectFlag(
true);
2186 previous_project_node->setModifiedTableCatalog(&
catalog_);
2188 int target_update_column_expr_start = 0;
2190 CHECK(target_update_column_expr_start >= 0);
2191 CHECK(target_update_column_expr_end >= 0);
2193 bool varlen_update_required =
false;
2195 auto varlen_scan_visitor = [
this,
2196 &varlen_update_required,
2197 target_update_column_expr_start,
2198 target_update_column_expr_end](
int index) {
2199 if (index >= target_update_column_expr_start &&
2200 index <= target_update_column_expr_end) {
2201 auto target_index = index - target_update_column_expr_start;
2208 const auto shard_cd =
2211 if ((column_desc->columnName == shard_cd->columnName)) {
2212 throw std::runtime_error(
"UPDATE of a shard key is currently unsupported.");
2217 if (column_desc->columnType.is_varlen()) {
2218 varlen_update_required =
true;
2220 if (column_desc->columnType.is_geometry()) {
2221 throw std::runtime_error(
"UPDATE of a geo column is unsupported.");
2226 previous_project_node->visitScalarExprs(varlen_scan_visitor);
2227 previous_project_node->setVarlenUpdateRequired(varlen_update_required);
2232 CHECK(previous_node !=
nullptr);
2233 auto previous_project_node =
const_cast<RelProject*
>(previous_node);
2236 previous_project_node->setModifiedTableCatalog(&
catalog_);
2256 std::vector<std::string>& fields,
2257 std::vector<const Rex*> col_inputs,
2258 std::vector<std::unique_ptr<const RexScalar>>& table_func_inputs,
2259 std::vector<std::unique_ptr<const RexScalar>>& target_exprs)
2265 for (
const auto& input : inputs) {
2272 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
2273 std::shared_ptr<const RelAlgNode> input)
override;
2318 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2319 return std::make_shared<RelTableFunction>(*this);
2325 if (!config.skip_input_nodes) {
2328 ret +=
", input node id={";
2330 auto node_id_in_plan = input->getIdInPlanTree();
2331 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
2333 ret += node_id_str +
" ";
2339 if (!config.skip_input_nodes) {
2343 ret += expr->toString(config) +
" ";
2346 ret +=
", target_exprs=";
2348 ret += expr->toString(config) +
" ";
2350 return cat(ret,
")");
2357 boost::hash_combine(*
hash_, table_func_input->toHash());
2360 boost::hash_combine(*
hash_, target_expr->toHash());
2365 boost::hash_combine(*
hash_, node->toHash());
2380 std::vector<std::unique_ptr<const RexScalar>>
2389 using RowValues = std::vector<std::unique_ptr<const RexScalar>>;
2395 std::vector<RowValues>& values)
2405 for (
const auto& target_meta_info :
tuple_type_) {
2406 ret +=
" (" + target_meta_info.get_resname() +
" " +
2407 target_meta_info.get_type_info().get_type_name() +
")";
2417 boost::hash_combine(*
hash_, target_meta_info.get_resname());
2418 boost::hash_combine(*
hash_, target_meta_info.get_type_info().get_type_name());
2431 const auto& row =
values_[row_idx];
2433 return row[col_idx].get();
2440 return values_.front().size();
2450 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2451 return std::make_shared<RelLogicalValues>(*this);
2467 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2468 return std::make_shared<RelLogicalUnion>(*this);
2470 size_t size()
const override;
2473 size_t toHash()
const override;
2516 const auto& last_ptr =
nodes_.back();
2543 Hints* hints_delivered,
2545 std::optional<bool> has_global_columnar_output_hint = std::nullopt;
2546 std::optional<bool> has_global_rowwise_output_hint = std::nullopt;
2548 for (
auto it = hints_delivered->begin(); it != hints_delivered->end(); it++) {
2549 auto target = it->second;
2550 auto hint_type = it->first;
2551 switch (hint_type) {
2555 if (target.isGlobalHint()) {
2562 has_global_columnar_output_hint = target.isGlobalHint();
2566 has_global_rowwise_output_hint = target.isGlobalHint();
2570 if (target.getListOptions().size() != 1) {
2571 VLOG(1) <<
"Skip the given query hint \"overlaps_bucket_threshold\" ("
2572 << target.getListOptions()[0]
2573 <<
") : invalid # hint options are given";
2576 double overlaps_bucket_threshold = std::stod(target.getListOptions()[0]);
2577 if (overlaps_bucket_threshold >= 0.0 && overlaps_bucket_threshold <= 90.0) {
2580 if (target.isGlobalHint()) {
2585 VLOG(1) <<
"Skip the given query hint \"overlaps_bucket_threshold\" ("
2586 << overlaps_bucket_threshold
2587 <<
") : the hint value should be within 0.0 ~ 90.0";
2592 if (target.getListOptions().size() != 1) {
2593 VLOG(1) <<
"Skip the given query hint \"overlaps_max_size\" ("
2594 << target.getListOptions()[0]
2595 <<
") : invalid # hint options are given";
2598 std::stringstream ss(target.getListOptions()[0]);
2599 int overlaps_max_size;
2600 ss >> overlaps_max_size;
2601 if (overlaps_max_size >= 0) {
2604 if (target.isGlobalHint()) {
2609 VLOG(1) <<
"Skip the query hint \"overlaps_max_size\" (" << overlaps_max_size
2610 <<
") : the hint value should be larger than or equal to zero";
2617 if (target.isGlobalHint()) {
2626 if (target.isGlobalHint()) {
2630 VLOG(1) <<
"Skip auto tuner and hashtable caching for overlaps join.";
2634 if (target.getListOptions().size() != 1) {
2635 VLOG(1) <<
"Skip the given query hint \"overlaps_keys_per_bin\" ("
2636 << target.getListOptions()[0]
2637 <<
") : invalid # hint options are given";
2640 double overlaps_keys_per_bin = std::stod(target.getListOptions()[0]);
2641 if (overlaps_keys_per_bin > 0.0 &&
2642 overlaps_keys_per_bin < std::numeric_limits<double>::max()) {
2645 if (target.isGlobalHint()) {
2650 VLOG(1) <<
"Skip the given query hint \"overlaps_keys_per_bin\" ("
2651 << overlaps_keys_per_bin
2652 <<
") : the hint value should be larger than zero";
2658 VLOG(1) <<
"Skip query hint \'keep_result\' because neither data recycler "
2659 "nor query resultset recycler is enabled";
2663 if (target.isGlobalHint()) {
2672 VLOG(1) <<
"Skip query hint \'keep_table_function_result\' because neither "
2674 "nor query resultset recycler is enabled";
2683 if (target.getListOptions().size() != 1u) {
2684 VLOG(1) <<
"Skip the given query hint \"aggregate_tree_fanout\" ("
2685 << target.getListOptions()[0]
2686 <<
") : invalid # hint options are given";
2689 int aggregate_tree_fanout = std::stoi(target.getListOptions()[0]);
2690 if (aggregate_tree_fanout < 0) {
2691 VLOG(1) <<
"A fan-out of an aggregate tree should be larger than zero";
2692 }
else if (aggregate_tree_fanout > 1024) {
2693 VLOG(1) <<
"Too large fanout is provided (i.e., fanout < 1024)";
2697 if (target.isGlobalHint()) {
2705 CHECK_EQ(1u, target.getListOptions().size());
2706 int cuda_block_size = std::stoi(target.getListOptions()[0]);
2707 if (cuda_block_size <= 0) {
2708 VLOG(1) <<
"CUDA block size should be larger than zero";
2709 }
else if (cuda_block_size > 1024) {
2710 VLOG(1) <<
"CUDA block size should be less or equal to 1024";
2714 if (target.isGlobalHint()) {
2722 CHECK_EQ(1u, target.getListOptions().size());
2723 double cuda_grid_size_multiplier = std::stod(target.getListOptions()[0]);
2724 double min_grid_size_multiplier{0};
2725 double max_grid_size_multiplier{1024};
2726 if (cuda_grid_size_multiplier <= min_grid_size_multiplier) {
2727 VLOG(1) <<
"CUDA grid size multiplier should be larger than zero";
2728 }
else if (cuda_grid_size_multiplier > max_grid_size_multiplier) {
2729 VLOG(1) <<
"CUDA grid size multiplier should be less than 1024";
2733 if (target.isGlobalHint()) {
2743 if (target.isGlobalHint()) {
2751 VLOG(1) <<
"Skip the given query hint \"watchdog\": already enabled";
2755 if (target.isGlobalHint()) {
2764 VLOG(1) <<
"Skip the given query hint \"watchdog_off\": already disabled";
2768 if (target.isGlobalHint()) {
2770 global_query_hint.
watchdog =
false;
2778 VLOG(1) <<
"Skip the given query hint \"dynamic_watchdog\": already enabled";
2782 if (target.isGlobalHint()) {
2792 <<
"Skip the given query hint \"dynamic_watchdog_off\": already disabled";
2796 if (target.isGlobalHint()) {
2805 hints_delivered->end()) {
2806 VLOG(1) <<
"Skip the given query hint \"query_time_limit\" ("
2807 << target.getListOptions()[0]
2808 <<
") : cannot use it with \"dynamic_watchdog_off\" hint";
2811 if (target.getListOptions().size() != 1) {
2812 VLOG(1) <<
"Skip the given query hint \"query_time_limit\" ("
2813 << target.getListOptions()[0]
2814 <<
") : invalid # hint options are given";
2817 double query_time_limit = std::stoi(target.getListOptions()[0]);
2818 if (query_time_limit <= 0) {
2819 VLOG(1) <<
"Skip the given query hint \"query_time_limit\" ("
2820 << target.getListOptions()[0]
2821 <<
") : the hint value should be larger than zero";
2826 if (target.isGlobalHint()) {
2835 if (target.isGlobalHint()) {
2844 if (target.isGlobalHint()) {
2851 CHECK_EQ(1u, target.getListOptions().size());
2852 int loop_size_threshold = std::stoi(target.getListOptions()[0]);
2853 if (loop_size_threshold <= 0) {
2854 VLOG(1) <<
"The loop size threshold should be larger than zero";
2858 if (target.isGlobalHint()) {
2866 CHECK_EQ(1u, target.getListOptions().size());
2867 int max_join_hash_table_size = std::stoi(target.getListOptions()[0]);
2868 if (max_join_hash_table_size <= 0) {
2869 VLOG(1) <<
"The maximum hash table size should be larger than zero";
2873 if (target.isGlobalHint()) {
2896 if (has_global_columnar_output_hint.has_value() &&
2897 has_global_rowwise_output_hint.has_value()) {
2899 <<
"Two hints 1) columnar output and 2) rowwise output are enabled together, "
2900 <<
"so skip them and use the runtime configuration "
2901 "\"g_enable_columnar_output\"";
2902 }
else if (has_global_columnar_output_hint.has_value() &&
2903 !has_global_rowwise_output_hint.has_value()) {
2905 VLOG(1) <<
"We already enable columnar output by default "
2906 "(g_enable_columnar_output = true), so skip this columnar output hint";
2910 if (*has_global_columnar_output_hint) {
2915 }
else if (!has_global_columnar_output_hint.has_value() &&
2916 has_global_rowwise_output_hint.has_value()) {
2918 VLOG(1) <<
"We already use the default rowwise output (g_enable_columnar_output "
2919 "= false), so skip this rowwise output hint";
2923 if (*has_global_rowwise_output_hint) {
2933 auto node_key = node->
toHash();
2936 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2937 hint_map.emplace(node->
getId(), query_hint);
2940 it->second.emplace(node->
getId(), query_hint);
2947 auto const& registered_query_hint_map = node_it->second;
2948 auto hint_it = registered_query_hint_map.find(node->
getId());
2949 if (hint_it != registered_query_hint_map.end()) {
2950 auto const& registered_query_hint = hint_it->second;
2953 return std::make_optional(registered_query_hint ||
global_hints_);
2955 return std::make_optional(registered_query_hint);
2964 return std::nullopt;
2967 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2986 std::vector<std::shared_ptr<RelAlgNode>>
nodes_;
2992 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>
3010 return rel_alg_dag.
nodes_;
3018 static std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
3043 static std::unique_ptr<RelAlgDag>
buildDag(
const std::string& query_ra,
3044 const bool optimize_dag);
3056 const rapidjson::Value& query_ast);
3061 static std::unique_ptr<RelAlgDag>
build(
const rapidjson::Value& query_ast,
3063 const bool optimize_dag);
std::vector< std::shared_ptr< const RexScalar > > scalar_exprs_
std::shared_ptr< RelAlgNode > deepCopy() const override
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const size_t getGroupByCount() const
void setGlobalQueryHints(const RegisteredQueryHint &global_hints)
virtual std::string toString(RelRexToStringConfig config) const =0
bool isRowOffsetPreceding() const
bool is_agg(const Analyzer::Expr *expr)
void validate_non_foreign_table_write(const TableDescriptor *table_descriptor)
SortField getCollation(const size_t i) const
std::unique_ptr< const RexScalar > condition_
RexWindowBound frame_start_bound_
RelCompound(const TableDescriptor *td, const Catalog_Namespace::Catalog *catalog)
const RexScalar * getThen(const size_t idx) const
void setOutputMetainfo(std::vector< TargetMetaInfo > targets_metainfo) const
bool isNestedLoopQual() const
std::unique_ptr< const RexScalar > ConstRexScalarPtr
std::vector< std::unique_ptr< const RexScalar > > getExpressionsAndRelease()
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
void setVarlenUpdateRequired(bool required) const
RexLiteral(const bool val, const SQLTypes type, const SQLTypes target_type, const unsigned scale, const unsigned precision, const unsigned target_scale, const unsigned target_precision)
std::vector< std::unique_ptr< const RexScalar > > outer_conditions_per_level_
bool const isFlattened() const
std::unique_ptr< RexSubQuery > deepCopy() const
ConstRexScalarPtrVector getPartitionKeysAndRelease() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
const std::vector< std::shared_ptr< RexSubQuery > > & getSubqueries() const
std::shared_ptr< RelAlgNode > deepCopy() const override
int getUpdateColumnCount() const
static std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > & getQueryHints(RelAlgDag &rel_alg_dag)
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
ColumnNameList target_columns_
bool g_use_query_resultset_cache
const bool hasHintEnabled(QueryHint candidate_hint) const
std::vector< std::unique_ptr< const RexScalar > > table_func_inputs_
size_t toHash() const override
void replacePartitionKey(size_t offset, std::unique_ptr< const RexScalar > &&new_partition_key)
const Rex * getTargetExpr(const size_t i) const
size_t toHash() const override
TableDescriptor const * getTableDescriptor() const
RelAlgNode(RelAlgInputs inputs={})
std::string getOpTypeInfo() const
size_t size() const override
class for a per-database catalog. also includes metadata for the current database and the current use...
Hints * getDeliveredHints()
RexFunctionOperator()=default
const std::vector< std::shared_ptr< const Analyzer::Expr > > getFilterCond() const
size_t size() const override
std::shared_ptr< RelAlgNode > deepCopy() const override
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
void addHint(const ExplainedQueryHint &hint_explained)
bool coversOriginalNode(const RelAlgNode *node) const
const RexScalar * getFilterExpr() const
size_t size() const override
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t getOperand(size_t idx) const
TargetColumnList const & getUpdateColumnNames() const
std::vector< RexInput > RANodeOutput
const RexScalar * getElse() const
RexOperator(const SQLOps op, std::vector< std::unique_ptr< const RexScalar >> &operands, const SQLTypeInfo &type)
void setPushedDownWindowExpr()
static thread_local unsigned crt_id_
NullSortedPosition nulls_pos_
void setCondition(std::unique_ptr< const RexScalar > &condition)
void setTargetColumns(ColumnNameList const &target_columns) const
std::string function_name_
const std::string getFieldName(const size_t i) const
std::unique_ptr< RexRef > deepCopy() const
const RexScalar * outer_join_cond_
void setEmptyResult(bool emptyResult)
bool overlaps_allow_gpu_build
const Catalog_Namespace::Catalog & getCatalog() const
RelProject(const TableDescriptor *td, const Catalog_Namespace::Catalog *catalog)
RexScalar const * copyAndRedirectSource(RexScalar const *, size_t input_idx) const
std::unique_ptr< const RexScalar > ConstRexScalarPtr
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
const RexScalar * getOuterCondition(const size_t nesting_level) const
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
void setQueryPlanDag(const std::string &extracted_query_plan_dag) const
unsigned getTargetScale() const
void applyDeleteModificationsToInputNode()
bool operator==(const SortField &that) const
std::vector< std::string > TargetColumnList
size_t size() const override
const SQLTypeInfo & getType() const
Hints * getDeliveredHints()
const RexScalar * getOperand(const size_t idx) const
size_t size() const override
std::vector< const Rex * > col_inputs_
const JoinType join_type_
bool hasEquivCollationOf(const RelSort &that) const
const std::vector< SortField > & getCollation() const
void resetQueryExecutionState()
SortDirection getSortDir() const
size_t getNumRows() const
std::shared_ptr< RelFilter > original_filter_
const SQLTypeInfo & getType() const
size_t toHash() const override
const bool hasHintEnabled(QueryHint candidate_hint) const
void setRelNodeDagId(const size_t id) const
const std::vector< const Analyzer::ColumnVar * > lhs_join_cols_
void applyUpdateModificationsToInputNode()
std::string getFieldName(const size_t idx) const
const RexScalar * getCondition() const
RexSubQuery & operator=(const RexSubQuery &)=delete
std::unique_ptr< const RexScalar > else_expr_
std::vector< std::shared_ptr< RelAlgNode > > nodes_
const std::vector< TargetMetaInfo > getTupleType() const
size_t toHash() const override
const std::vector< std::string > & getFields() const
void addManagedInput(std::shared_ptr< const RelAlgNode > input)
unsigned getScale() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::optional< size_t > getIdInPlanTree() const
void invalidateTargetColumns() const
void registerQueryHint(const RelAlgNode *node, const RegisteredQueryHint &query_hint)
std::vector< std::string > fields_
size_t toHash() const override
std::vector< std::unique_ptr< const RexAgg > > getAggExprsAndRelease()
void addHint(const ExplainedQueryHint &hint_explained)
std::shared_ptr< RelAlgNode > deepCopy() const override
void setDeleteViaSelectFlag(bool required) const
const RexScalar * getWhen(const size_t idx) const
const RegisteredQueryHint & getGlobalHints() const
double overlaps_keys_per_bin
void setFields(std::vector< std::string > &&fields)
auto const isProjectForUpdate() const
void setFilterExpr(std::unique_ptr< const RexScalar > &new_expr)
std::optional< bool > dynamic_watchdog
std::vector< const Analyzer::ColumnVar * > getJoinCols(bool lhs) const
void appendInput(std::string new_field_name, std::unique_ptr< const RexScalar > new_input)
double cuda_grid_size_multiplier
const RexScalar * getCondition() const
std::string getOpType() const
bool has_pushed_down_window_expr_
std::string query_plan_dag_
std::shared_ptr< RelAlgNode > deepCopy() const override
bool g_enable_dynamic_watchdog
void addHint(const ExplainedQueryHint &hint_explained)
std::vector< ConstRexScalarPtr > ConstRexScalarPtrVector
void forceRowwiseOutput() const
RelFilter(std::unique_ptr< const RexScalar > &filter)
const TableDescriptor * td_
RexLiteral(const std::string &val, const SQLTypes type, const SQLTypes target_type, const unsigned scale, const unsigned precision, const unsigned target_scale, const unsigned target_precision)
const std::string op_type_
const RexScalar * getOperandAndRelease(const size_t idx) const
std::vector< std::unique_ptr< const RexScalar > > scalar_sources_
std::vector< std::shared_ptr< const RelJoin > > original_joins_
bool g_enable_data_recycler
const ColumnDescriptor * getShardColumnMetadataForTable(const TableDescriptor *td) const
virtual std::shared_ptr< RelAlgNode > deepCopy() const =0
std::shared_ptr< const RexScalar > bound_expr
static std::vector< std::shared_ptr< RexSubQuery > > & getSubqueries(RelAlgDag &rel_alg_dag)
const RaExecutionDesc * context_data_
std::shared_ptr< const RelAlgNode > getAndOwnInput(const size_t idx) const
std::vector< std::string > field_names_
bool isCurrentRow() const
virtual std::unique_ptr< const RexOperator > getDisambiguated(std::vector< std::unique_ptr< const RexScalar >> &operands) const
size_t max_join_hash_table_size
size_t toHash() const override
const std::string getFieldName(const size_t i) const
bool hasPushedDownWindowExpr() const
RexWindowFunctionOperator()
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > & getQueryHints()
void clearContextData() const
TableDescriptor const *const getTableDescriptor() const
std::shared_ptr< const RelAlgNode > getRootNodeShPtr() const
bool opt_cuda_grid_and_block_size
RexWindowFunctionOperator(const SqlWindowFunctionKind kind, ConstRexScalarPtrVector &operands, ConstRexScalarPtrVector &partition_keys, ConstRexScalarPtrVector &order_keys, const std::vector< SortField > collation, const RexWindowBound &frame_start_bound, const RexWindowBound &frame_end_bound, const bool is_rows, const SQLTypeInfo &ti)
boost::variant< boost::blank, int64_t, double, std::string, bool > literal_
const std::string getFieldName(const size_t i) const
size_t getQueryPlanDagHash() const
const std::string qualifier_
std::vector< SortField > collation_
const RelAlgNode & getRootNode() const
RelLogicalValues()=default
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t getRowsSize() const
size_t getColInputsSize() const
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
void setUpdateViaSelectFlag(bool required) const
void setIdInPlanTree(size_t id) const
This file contains the class specification and related data structures for Catalog.
RelScan(const TableDescriptor *td, const Catalog_Namespace::Catalog &catalog)
const size_t getScalarSourcesSize() const
void setExpressions(std::vector< std::unique_ptr< const RexScalar >> &exprs) const
std::string to_string() const
const RelAlgNode * getRHS() const
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
bool g_enable_columnar_output
virtual std::string toString(RelRexToStringConfig config) const =0
auto const isRowwiseOutputForced() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t toHash() const override
bool is_delete_via_select_
SQLOps getOperator() const
void setExecutionResult(const ExecutionResultShPtr result)
std::shared_ptr< const RelAlgNode > RelAlgNodeInputPtr
const RexScalar * getCondition() const
bool keep_table_function_result
std::shared_ptr< RelAlgNode > deepCopy() const override
const Catalog_Namespace::Catalog * catalog_
RelLeftDeepInnerJoin()=default
static std::unique_ptr< RelAlgDag > buildDagForSubquery(RelAlgDag &root_dag, const rapidjson::Value &query_ast)
const RexScalar * getTableFuncInputAtAndRelease(const size_t idx)
SqlWindowFunctionKind kind_
RelModify(Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td)
const SQLTypeInfo & getType() const
const bool hasHintEnabled(const QueryHint candidate_hint) const
ColumnNameList const & getTargetColumns() const
std::vector< std::shared_ptr< RexSubQuery > > subqueries_
bool isUnboundedFollowing() const
std::unique_ptr< const RexOperator > disambiguatedOperands(ConstRexScalarPtrVector &operands, ConstRexScalarPtrVector &partition_keys, ConstRexScalarPtrVector &order_keys, const std::vector< SortField > &collation) const
RexCase(std::vector< std::pair< std::unique_ptr< const RexScalar >, std::unique_ptr< const RexScalar >>> &expr_pair_list, std::unique_ptr< const RexScalar > &else_expr)
NullSortedPosition getNullsPosition() const
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
RelSort(const std::vector< SortField > &collation, const size_t limit, const size_t offset, std::shared_ptr< const RelAlgNode > input, bool limit_delivered)
std::vector< size_t > operands_
size_t toHash() const override
Hints * getDeliveredHints()
std::vector< std::string > fields_
RelScan(const TableDescriptor *td, const std::vector< std::string > &field_names, const Catalog_Namespace::Catalog &catalog)
const RexScalar * getAndReleaseCondition() const
std::unique_ptr< Hints > hints_
RexLiteral(const int64_t val, const SQLTypes type, const SQLTypes target_type, const unsigned scale, const unsigned precision, const unsigned target_scale, const unsigned target_precision)
const TableDescriptor * table_descriptor_
std::unique_ptr< Hints > hints_
std::vector< std::shared_ptr< const RelAlgNode >> RelAlgInputs
std::optional< RegisteredQueryHint > getQueryHint(const RelAlgNode *node) const
std::vector< std::unique_ptr< const RexScalar > > scalar_exprs_
void registerHint(const QueryHint hint)
std::shared_ptr< RelAlgNode > deepCopy() const override
size_t size() const override
std::shared_ptr< SQLTypeInfo > type_
size_t size() const override
const RexScalar * getAndReleaseCondition()
std::string getFieldName(const size_t i) const
const ColumnDescriptor * getMetadataForColumn(int tableId, const std::string &colName) const
void addHint(const ExplainedQueryHint &hint_explained)
size_t branchCount() const
RexSubQuery(const std::shared_ptr< const RelAlgNode > ra)
const RelAlgNode * getInput(const size_t idx) const
bool force_rowwise_output_
RelFilter(std::unique_ptr< const RexScalar > &filter, std::shared_ptr< const RelAlgNode > input)
const std::vector< std::shared_ptr< const Analyzer::Expr > > filter_ops_
std::vector< std::shared_ptr< const RelJoin > > getOriginalJoins() const
bool varlen_update_required_
Catalog_Namespace::Catalog const & catalog_
std::string getQueryPlanDag() const
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_
void setCondition(std::unique_ptr< const RexScalar > &condition)
std::vector< std::unique_ptr< const RexScalar > > operands_
std::optional< size_t > hash_
void setContextData(const RaExecutionDesc *context_data) const
size_t toHash() const override
std::vector< std::string > fields_
size_t query_plan_dag_hash_
std::shared_ptr< RelAlgNode > deepCopy() const override
std::vector< const Rex * > target_exprs_
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
std::optional< size_t > hash_
const RexScalar * getProjectAtAndRelease(const size_t idx) const
const RexWindowBound & getFrameEndBound() const
void visitScalarExprs(EXPR_VISITOR_FUNCTOR visitor_functor) const
std::shared_ptr< ExecutionResultShPtr > result_
std::shared_ptr< RelAlgNode > deepCopy() const override
std::unique_ptr< Hints > hints_
std::string getFieldName(const size_t col_idx) const
size_t getTableFuncInputsSize() const
std::unique_ptr< RexLiteral > deepCopy() const
virtual void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input)
std::string toString() const
static std::string yieldModifyOperationString(ModifyOperation const op)
ModifyOperation getOperation() const
std::vector< TargetMetaInfo > getCompatibleMetainfoTypes() const
void setModifiedTableDescriptor(TableDescriptor const *td) const
void setFields(std::vector< std::string > &&fields)
size_t size() const override
std::shared_ptr< Fragmenter_Namespace::AbstractFragmenter > fragmenter
static std::unique_ptr< RelAlgDag > buildDag(const std::string &query_ra, const bool optimize_dag)
std::string tree_string(const RelAlgNode *ra, const size_t depth)
static ModifyOperation yieldModifyOperationEnum(std::string const &op_string)
void setScalarSources(std::vector< std::unique_ptr< const RexScalar >> &new_sources)
std::vector< RowValues > values_
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
std::vector< TargetMetaInfo > targets_metainfo_
const std::vector< std::unique_ptr< const RexAgg > > & getAggExprs() const
Hints * getDeliveredHints()
void setTableFuncInputs(std::vector< std::unique_ptr< const RexScalar >> &&exprs)
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::optional< bool > watchdog
bool isEmptyResult() const
const RelAlgNode * getRelAlg() const
size_t size() const override
size_t toHash() const override
size_t size() const override
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const RexScalar * getProjectAt(const size_t idx) const
bool isRowOffsetFollowing() const
const RaExecutionDesc * getContextData() const
const std::vector< std::string > & getFields() const
bool hasInput(const RelAlgNode *needle) const
const std::vector< std::string > & getFieldNames() const
const std::vector< std::string > & getFields() const
const std::vector< const Analyzer::ColumnVar * > rhs_join_cols_
static std::unique_ptr< RelAlgDag > build(const rapidjson::Value &query_ast, RelAlgDag *root_dag, const bool optimize_dag)
void setCollation(std::vector< SortField > &&collation)
int32_t countRexLiteralArgs() const
std::unique_ptr< Hints > hints_
unsigned target_precision_
const ConstRexScalarPtrVector & getPartitionKeys() const
const RelAlgNode * getLHS() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const RexWindowBound & getFrameStartBound() const
std::unique_ptr< Hints > hints_
void addHint(const ExplainedQueryHint &hint_explained)
const RexScalar * getOuterJoinCond() const
bool hasNoFraming() const
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::vector< RexLiteral > RexLiteralArray
void resetModifyManipulationTarget() const
void registerSubquery(std::shared_ptr< RexSubQuery > subquery)
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
std::shared_ptr< const RelAlgNode > ra_
static RelRexToStringConfig defaults()
SortField(const size_t field, const SortDirection sort_dir, const NullSortedPosition nulls_pos)
std::unique_ptr< const RexScalar > filter_expr_
static std::vector< std::shared_ptr< RelAlgNode > > & getNodes(RelAlgDag &rel_alg_dag)
void resetQueryExecutionState()
bool hasWindowFunctionExpr() const
std::vector< ConstRexScalarPtr > ConstRexScalarPtrVector
ConstRexScalarPtrVector order_keys_
SqlWindowFunctionKind getKind() const
const size_t getGroupByCount() const
std::unordered_map< QueryHint, ExplainedQueryHint > Hints
size_t toHash() const override
size_t collationCount() const
RelModify(Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td, bool flattened, ModifyOperation op, TargetColumnList const &target_column_list, RelAlgNodeInputPtr input)
virtual size_t size() const =0
std::vector< SortField > collation_
auto const isDeleteViaSelect() const
bool operator==(const RelSort &that) const
RexWindowBound frame_end_bound_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const RelFilter * getOriginalFilter() const
std::shared_ptr< RelAlgNode > deepCopy() const override
JoinType getJoinType() const
RelLogicalValues(const std::vector< TargetMetaInfo > &tuple_type, std::vector< RowValues > &values)
std::string get_type_name() const
std::unique_ptr< const RexOperator > getDisambiguated(std::vector< std::unique_ptr< const RexScalar >> &operands) const override
std::optional< size_t > id_in_plan_tree_
void replaceOrderKey(size_t offset, std::unique_ptr< const RexScalar > &&new_order_key)
const size_t getNumShards() const
std::vector< std::pair< std::unique_ptr< const RexScalar >, std::unique_ptr< const RexScalar > > > expr_pair_list_
std::string typeName(const T *v)
size_t toHash() const override
RexFunctionOperator(const std::string &name, ConstRexScalarPtrVector &operands, const SQLTypeInfo &ti)
std::unique_ptr< const RexScalar > condition_
void replaceOperands(std::vector< std::unique_ptr< const RexScalar >> &&new_operands)
const Catalog_Namespace::Catalog & getCatalog() const
const RexScalar * getTableFuncInputAt(const size_t idx) const
std::vector< RexLiteralArray > TupleContentsArray
void eachNode(std::function< void(RelAlgNode const *)> const &) const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
unsigned getPrecision() const
const JoinType getJoinType(const size_t nesting_level) const
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)
std::string getFunctionName() const
void propagateModifyManipulationTarget(std::shared_ptr< RelProject > new_project_node) const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::optional< bool > use_loop_join
std::vector< const RexAgg * > getAggregatesAndRelease()
const std::vector< std::string > & getFields() const
std::string getFieldName(const size_t i) const
static void optimizeDag(RelAlgDag &rel_alg_dag)
const RexScalar * getValueAt(const size_t row_idx, const size_t col_idx) const
size_t toHash() const override
std::vector< std::string > ColumnNameList
bool g_enable_watchdog false
const RexScalar * getInnerCondition() const
ModifyOperation operation_
ConstRexScalarPtrVector getOrderKeysAndRelease() const
const ConstRexScalarPtrVector & getOrderKeys() const
auto const isUpdateViaSelect() const
const std::string op_typeinfo_
const Catalog_Namespace::Catalog & catalog_
SQLTypes getTargetType() const
ConstRexScalarPtrVector partition_keys_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
void setModifiedTableCatalog(const Catalog_Namespace::Catalog *catalog) const
bool isUnboundedPreceding() const
RexLiteral(const double val, const SQLTypes type, const SQLTypes target_type, const unsigned scale, const unsigned precision, const unsigned target_scale, const unsigned target_precision)
void setFields(std::vector< std::string > &&fields)
const RexAgg * getAggExpr(size_t i) const
size_t loop_join_inner_table_max_num_rows
RegisteredQueryHint global_hints_
std::shared_ptr< RelAlgNode > deepCopy() const override
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::shared_ptr< RelAlgNode > deepCopy() const override
void injectOffsetInFragmentExpr() const
const size_t getNumFragments() const
size_t getAggExprSize() const
virtual size_t toHash() const =0
std::string getQualifier() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
RexLiteral(const SQLTypes target_type)
QueryNotSupported(const std::string &reason)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t size() const override
std::vector< std::unique_ptr< const RexScalar >> RowValues
size_t toHash() const override
const size_t getAggExprsCount() const
const std::string & getName() const
const size_t inputCount() const
ExecutionResultShPtr getExecutionResult() const
size_t getRelNodeDagId() const
auto const isVarlenUpdateRequired() const
double overlaps_bucket_threshold
size_t toHash() const override
RexAgg(const SQLAgg agg, const bool distinct, const SQLTypeInfo &type, const std::vector< size_t > &operands)
size_t aggregate_tree_fanout
const RexScalar * getAndReleaseCondition() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t toHash() const override
size_t size() const override
std::unique_ptr< RexAgg > deepCopy() const
size_t toHash() const override
void setFields(std::vector< std::string > &&new_fields)
const QueryHint getHint() const
size_t size() const override
const std::vector< TargetMetaInfo > & getOutputMetainfo() const
const TableDescriptor * getTableDescriptor() const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
RelTableFunction()=default
TargetColumnList target_column_list_
TableDescriptor const * table_descriptor_
void setAggExprs(std::vector< std::unique_ptr< const RexAgg >> &agg_exprs)
std::vector< std::string > fields_
JoinType getJoinType() const
bool hasContextData() const
bool isLimitDelivered() const
RelTranslatedJoin(const RelAlgNode *lhs, const RelAlgNode *rhs, const std::vector< const Analyzer::ColumnVar * > lhs_join_cols, const std::vector< const Analyzer::ColumnVar * > rhs_join_cols, const std::vector< std::shared_ptr< const Analyzer::Expr >> filter_ops, const RexScalar *outer_join_cond, const bool nested_loop, const JoinType join_type, const std::string &op_type, const std::string &qualifier, const std::string &op_typeinfo)
size_t getFilterCondSize() const
const bool hasHintEnabled(QueryHint candidate_hint) const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
has_pushed_down_window_expr_
size_t toHash() const override
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
RANodeOutput get_node_output(const RelAlgNode *ra_node)
bool isAnyQueryHintDelivered() const
std::shared_ptr< RelAlgNode > deepCopy() const override
unsigned getTargetPrecision() const
virtual size_t toHash() const =0
ModifyManipulationTarget(bool const update_via_select=false, bool const delete_via_select=false, bool const varlen_update_required=false, TableDescriptor const *table_descriptor=nullptr, ColumnNameList target_columns=ColumnNameList(), const Catalog_Namespace::Catalog *catalog=nullptr)
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
RelModify(Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td, bool flattened, std::string const &op_string, TargetColumnList const &target_column_list, RelAlgNodeInputPtr input)
RexSubQuery(std::shared_ptr< SQLTypeInfo > type, std::shared_ptr< ExecutionResultShPtr > result, const std::shared_ptr< const RelAlgNode > ra)
std::shared_ptr< const ExecutionResult > ExecutionResultShPtr
bool is_update_via_select_
const RexScalar * getTargetExpr(size_t idx) const
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
RexRef(const size_t index)
std::vector< TargetMetaInfo > tuple_type_
TableDescriptor const * getModifiedTableDescriptor() const
void registerQueryHints(std::shared_ptr< RelAlgNode > node, Hints *hints_delivered, RegisteredQueryHint &global_query_hint)
void setCondition(std::unique_ptr< const RexScalar > &condition)
const std::string getFieldName(const size_t i) const
const RexScalar * getScalarSource(const size_t i) const
constexpr auto is_datetime(SQLTypes type)
const bool hasHintEnabled(QueryHint candidate_hint) const
size_t toHash() const override
std::vector< std::unique_ptr< const RexScalar > > target_exprs_
Hints * getDeliveredHints()
const Catalog_Namespace::Catalog * getModifiedTableCatalog() const
size_t toHash() const override
static void setBuildState(RelAlgDag &rel_alg_dag, const RelAlgDag::BuildState build_state)
bool validateTargetColumns(VALIDATION_FUNCTOR validator) const
static void resetRelAlgFirstId() noexcept