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_;
99 const unsigned precision,
100 const unsigned target_scale,
101 const unsigned target_precision)
117 const unsigned scale,
118 const unsigned precision,
119 const unsigned target_scale,
120 const unsigned target_precision)
134 const unsigned scale,
135 const unsigned precision,
136 const unsigned target_scale,
137 const unsigned target_precision)
151 const unsigned scale,
152 const unsigned precision,
153 const unsigned target_scale,
154 const unsigned target_precision)
176 const auto ptr = boost::get<T>(&
literal_);
195 std::ostringstream oss;
217 return std::make_unique<RexLiteral>(*this);
221 const boost::variant<int64_t, double, std::string, bool, void*>
literal_;
236 std::vector<std::unique_ptr<const RexScalar>>& operands,
241 std::vector<std::unique_ptr<const RexScalar>>& operands)
const {
265 ret += operand->toString(config) +
" ";
275 boost::hash_combine(*
hash_, operand->toHash());
284 mutable std::vector<std::unique_ptr<const RexScalar>>
operands_;
302 std::shared_ptr<std::shared_ptr<const ExecutionResult>>
result,
303 const std::shared_ptr<const RelAlgNode> ra)
316 return *(
type_.get());
325 unsigned getId()
const;
332 size_t toHash()
const override;
334 std::unique_ptr<RexSubQuery>
deepCopy()
const;
340 std::shared_ptr<std::shared_ptr<const ExecutionResult>>
result_;
341 const std::shared_ptr<const RelAlgNode>
ra_;
365 size_t toHash()
const override;
388 RexCase(std::vector<std::pair<std::unique_ptr<const RexScalar>,
389 std::unique_ptr<const RexScalar>>>& expr_pair_list,
390 std::unique_ptr<const RexScalar>& else_expr)
409 auto ret =
cat(::
typeName(
this),
"(expr_pair_list=");
411 ret += expr.first->toString(config) +
" " + expr.second->toString(config) +
" ";
431 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
447 std::vector<std::unique_ptr<const RexScalar>>& operands)
const override {
448 return std::unique_ptr<const RexOperator>(
458 ret += operand->toString(config) +
" ";
460 return cat(ret,
")");
469 boost::hash_combine(*
hash_, operand->toHash());
514 auto hash = boost::hash_value(
field_);
557 const std::vector<SortField> collation,
586 std::unique_ptr<const RexScalar>&& new_partition_key) {
591 void replaceOrderKey(
size_t offset, std::unique_ptr<const RexScalar>&& new_order_key) {
612 const std::vector<SortField>& collation)
const {
613 return std::unique_ptr<const RexOperator>(
629 ret += operand->toString(config) +
" ";
631 ret +=
", partition_keys=";
633 ret += key->toString(config) +
" ";
635 ret +=
", order_keys=";
637 ret += key->toString(config) +
" ";
639 return cat(ret,
")");
649 boost::hash_combine(*
hash_, collation.toHash());
652 boost::hash_combine(*
hash_, operand->toHash());
655 boost::hash_combine(*
hash_, key->toHash());
658 boost::hash_combine(*
hash_, key->toHash());
660 auto get_window_bound_hash =
663 boost::hash_value(bound.bound_expr ? bound.bound_expr->toHash() :
HASH_N);
664 boost::hash_combine(h, bound.unbounded);
665 boost::hash_combine(h, bound.preceding);
666 boost::hash_combine(h, bound.following);
667 boost::hash_combine(h, bound.is_current_row);
668 boost::hash_combine(h, bound.order_key);
708 std::unique_ptr<RexRef>
deepCopy()
const {
return std::make_unique<RexRef>(
index_); }
719 const std::vector<size_t>& operands)
740 boost::hash_combine(*
hash_, operand);
800 if (!extracted_query_plan_dag.empty()) {
841 for (
auto& input_ptr :
inputs_) {
842 if (input_ptr.get() == needle) {
850 std::shared_ptr<const RelAlgNode> input) {
851 for (
auto& input_ptr :
inputs_) {
852 if (input_ptr == old_input) {
871 virtual size_t toHash()
const = 0;
873 virtual size_t size()
const = 0;
875 virtual std::shared_ptr<RelAlgNode>
deepCopy()
const = 0;
889 mutable std::optional<size_t>
hash_;
937 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
977 bool const delete_via_select =
false,
978 bool const varlen_update_required =
false,
1009 template <
typename VALIDATION_FUNCTOR>
1012 if (validator(column_name) ==
false) {
1035 RelProject(std::vector<std::unique_ptr<const RexScalar>>& scalar_exprs,
1036 const std::vector<std::string>& fields,
1037 std::shared_ptr<const RelAlgNode> input)
1057 if (!dynamic_cast<const RexInput*>(expr.get())) {
1090 std::shared_ptr<const RelAlgNode> input)
override {
1095 std::shared_ptr<const RelAlgNode> old_input,
1096 std::shared_ptr<const RelAlgNode> input,
1097 std::optional<std::unordered_map<unsigned, unsigned>> old_to_new_index_map);
1100 std::unique_ptr<const RexScalar> new_input);
1106 ret += expr->toString(config) +
" ";
1115 boost::hash_combine(*
hash_, target_expr->toHash());
1122 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1123 return std::make_shared<RelProject>(*this);
1154 template <
typename EXPR_VISITOR_FUNCTOR>
1156 for (
int i = 0; i < static_cast<int>(
scalar_exprs_.size()); i++) {
1164 std::make_unique<RexFunctionOperator const>(std::string(
"OFFSET_IN_FRAGMENT"),
1167 fields_.emplace_back(
"EXPR$DELETE_OFFSET_IN_FRAGMENT");
1180 std::vector<std::unique_ptr<const RexAgg>>& agg_exprs,
1181 const std::vector<std::string>& fields,
1182 std::shared_ptr<const RelAlgNode> input)
1201 fields_ = std::move(new_fields);
1207 std::vector<const RexAgg*>
result;
1209 result.push_back(agg_expr.release());
1218 const std::vector<std::unique_ptr<const RexAgg>>&
getAggExprs()
const {
1222 void setAggExprs(std::vector<std::unique_ptr<const RexAgg>>& agg_exprs) {
1235 if (!config.skip_input_nodes) {
1238 ret +=
", input node id={";
1240 auto node_id_in_plan = input->getIdInPlanTree();
1241 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1243 ret += node_id_str +
" ";
1247 return cat(ret,
")");
1255 boost::hash_combine(*
hash_, agg_expr->toHash());
1258 boost::hash_combine(*
hash_, node->toHash());
1265 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1266 return std::make_shared<RelAggregate>(*this);
1305 std::shared_ptr<const RelAlgNode> rhs,
1306 std::unique_ptr<const RexScalar>& condition,
1329 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1330 std::shared_ptr<const RelAlgNode> input)
override;
1335 if (!config.skip_input_nodes) {
1338 ret +=
", input node id={";
1340 auto node_id_in_plan = input->getIdInPlanTree();
1341 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1343 ret += node_id_str +
" ";
1359 boost::hash_combine(*
hash_, node->toHash());
1368 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1369 return std::make_shared<RelJoin>(*this);
1410 const std::vector<const Analyzer::ColumnVar*> lhs_join_cols,
1411 const std::vector<const Analyzer::ColumnVar*> rhs_join_cols,
1412 const std::vector<std::shared_ptr<const Analyzer::Expr>> filter_ops,
1414 const bool nested_loop,
1416 const std::string& op_type,
1417 const std::string& qualifier,
1418 const std::string& op_typeinfo)
1434 "( join_quals { lhs: ",
1438 " }, filter_quals: { ",
1440 " }, outer_join_cond: { ",
1466 boost::hash_combine(*
hash_, filter_op->toString());
1474 const std::vector<std::shared_ptr<const Analyzer::Expr>>
getFilterCond()
const {
1481 size_t size()
const override {
return 0; }
1493 std::shared_ptr<const RelAlgNode> input)
override {
1496 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1526 std::shared_ptr<const RelAlgNode> input)
1527 :
filter_(std::move(filter)) {
1545 filter_ = std::move(condition);
1550 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1551 std::shared_ptr<const RelAlgNode> input)
override;
1557 if (!config.skip_input_nodes) {
1560 ret +=
", input node id={";
1562 auto node_id_in_plan = input->getIdInPlanTree();
1563 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1565 ret += node_id_str +
" ";
1569 return cat(ret,
")");
1577 boost::hash_combine(*
hash_, node->toHash());
1583 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1584 return std::make_shared<RelFilter>(*this);
1596 std::vector<std::shared_ptr<const RelJoin>>& original_joins);
1607 size_t toHash()
const override;
1609 size_t size()
const override;
1611 std::shared_ptr<RelAlgNode>
deepCopy()
const override;
1636 const std::vector<const Rex*>& target_exprs,
1637 const size_t groupby_count,
1638 const std::vector<const RexAgg*>& agg_exprs,
1639 const std::vector<std::string>& fields,
1640 std::vector<std::unique_ptr<const RexScalar>>& scalar_sources,
1642 bool update_disguised_as_select =
false,
1643 bool delete_disguised_as_select =
false,
1644 bool varlen_update_required =
false,
1648 delete_disguised_as_select,
1649 varlen_update_required,
1650 manipulation_target_table,
1660 CHECK_EQ(fields.size(), target_exprs.size());
1661 for (
auto agg_expr : agg_exprs) {
1668 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1669 std::shared_ptr<const RelAlgNode> input)
override;
1709 size_t toHash()
const override;
1711 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1712 return std::make_shared<RelCompound>(*this);
1746 std::vector<std::unique_ptr<const RexScalar>>
1758 const size_t offset,
1759 std::shared_ptr<const RelAlgNode> input,
1760 bool limit_delivered)
1808 if (!config.skip_input_nodes) {
1811 ret +=
", input node id={";
1813 auto node_id_in_plan = input->getIdInPlanTree();
1814 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1816 ret += node_id_str +
" ";
1820 return cat(ret,
")");
1827 boost::hash_combine(*
hash_, collation.toHash());
1836 boost::hash_combine(*
hash_, node->toHash());
1844 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1845 return std::make_shared<RelSort>(*this);
1875 throw std::runtime_error(
"Unexpected ModifyOperation enum encountered.");
1879 if (op_string ==
"INSERT") {
1881 }
else if (op_string ==
"DELETE") {
1883 }
else if (op_string ==
"UPDATE") {
1887 throw std::runtime_error(
1888 std::string(
"Unsupported logical modify operation encountered " + op_string));
1894 std::string
const& op_string,
1927 size_t size()
const override {
return 0; }
1928 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1929 return std::make_shared<RelModify>(*this);
1941 ", target_column_list=",
1943 if (!config.skip_input_nodes) {
1946 ret +=
", input node id={";
1948 auto node_id_in_plan = input->getIdInPlanTree();
1949 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1951 ret += node_id_str +
" ";
1955 return cat(ret,
")");
1966 boost::hash_combine(*
hash_, node->toHash());
1975 CHECK(previous_project_node !=
nullptr);
1978 throw std::runtime_error(
1979 "UPDATE of a column using a window function is not currently supported.");
1989 int target_update_column_expr_start = 0;
1991 CHECK(target_update_column_expr_start >= 0);
1992 CHECK(target_update_column_expr_end >= 0);
1994 bool varlen_update_required =
false;
1996 auto varlen_scan_visitor = [
this,
1997 &varlen_update_required,
1998 target_update_column_expr_start,
1999 target_update_column_expr_end](
int index) {
2000 if (index >= target_update_column_expr_start &&
2001 index <= target_update_column_expr_end) {
2002 auto target_index = index - target_update_column_expr_start;
2009 const auto shard_cd =
2012 if ((column_desc->columnName == shard_cd->columnName)) {
2013 throw std::runtime_error(
"UPDATE of a shard key is currently unsupported.");
2018 if (column_desc->columnType.is_varlen()) {
2019 varlen_update_required =
true;
2021 if (column_desc->columnType.is_geometry()) {
2022 throw std::runtime_error(
"UPDATE of a geo column is unsupported.");
2034 CHECK(previous_project_node !=
nullptr);
2051 std::vector<std::string>& fields,
2052 std::vector<const Rex*> col_inputs,
2053 std::vector<std::unique_ptr<const RexScalar>>& table_func_inputs,
2054 std::vector<std::unique_ptr<const RexScalar>>& target_exprs)
2060 for (
const auto& input : inputs) {
2067 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
2068 std::shared_ptr<const RelAlgNode> input)
override;
2107 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2108 return std::make_shared<RelTableFunction>(*this);
2114 if (!config.skip_input_nodes) {
2117 ret +=
", input node id={";
2119 auto node_id_in_plan = input->getIdInPlanTree();
2120 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
2122 ret += node_id_str +
" ";
2128 if (!config.skip_input_nodes) {
2132 ret += expr->toString(config) +
" ";
2135 ret +=
", target_exprs=";
2137 ret += expr->toString(config) +
" ";
2139 return cat(ret,
")");
2146 boost::hash_combine(*
hash_, table_func_input->toHash());
2149 boost::hash_combine(*
hash_, target_expr->toHash());
2154 boost::hash_combine(*
hash_, node->toHash());
2164 std::vector<const Rex*>
2169 std::vector<std::unique_ptr<const RexScalar>>
2176 using RowValues = std::vector<std::unique_ptr<const RexScalar>>;
2179 std::vector<RowValues>& values)
2189 for (
const auto& target_meta_info :
tuple_type_) {
2190 ret +=
" (" + target_meta_info.get_resname() +
" " +
2191 target_meta_info.get_type_info().get_type_name() +
")";
2201 boost::hash_combine(*
hash_, target_meta_info.get_resname());
2202 boost::hash_combine(*
hash_, target_meta_info.get_type_info().get_type_name());
2210 const auto& row =
values_[row_idx];
2212 return row[col_idx].get();
2219 return values_.front().size();
2229 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2230 return std::make_shared<RelLogicalValues>(*this);
2241 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2242 return std::make_shared<RelLogicalUnion>(*this);
2244 size_t size()
const override;
2247 size_t toHash()
const override;
2288 const auto& last_ptr =
nodes_.back();
2315 Hints* hints_delivered,
2317 std::optional<bool> has_global_columnar_output_hint = std::nullopt;
2318 std::optional<bool> has_global_rowwise_output_hint = std::nullopt;
2320 for (
auto it = hints_delivered->begin(); it != hints_delivered->end(); it++) {
2321 auto target = it->second;
2322 auto hint_type = it->first;
2323 switch (hint_type) {
2327 if (target.isGlobalHint()) {
2334 has_global_columnar_output_hint = target.isGlobalHint();
2338 has_global_rowwise_output_hint = target.isGlobalHint();
2342 CHECK(target.getListOptions().size() == 1);
2343 double overlaps_bucket_threshold = std::stod(target.getListOptions()[0]);
2344 if (overlaps_bucket_threshold >= 0.0 && overlaps_bucket_threshold <= 90.0) {
2347 if (target.isGlobalHint()) {
2352 VLOG(1) <<
"Skip the given query hint \"overlaps_bucket_threshold\" ("
2353 << overlaps_bucket_threshold
2354 <<
") : the hint value should be within 0.0 ~ 90.0";
2359 CHECK(target.getListOptions().size() == 1);
2360 std::stringstream ss(target.getListOptions()[0]);
2361 int overlaps_max_size;
2362 ss >> overlaps_max_size;
2363 if (overlaps_max_size >= 0) {
2366 if (target.isGlobalHint()) {
2371 VLOG(1) <<
"Skip the query hint \"overlaps_max_size\" (" << overlaps_max_size
2372 <<
") : the hint value should be larger than or equal to zero";
2379 if (target.isGlobalHint()) {
2388 if (target.isGlobalHint()) {
2392 VLOG(1) <<
"Skip auto tuner and hashtable caching for overlaps join.";
2396 CHECK(target.getListOptions().size() == 1);
2397 double overlaps_keys_per_bin = std::stod(target.getListOptions()[0]);
2398 if (overlaps_keys_per_bin > 0.0 &&
2399 overlaps_keys_per_bin < std::numeric_limits<double>::max()) {
2402 if (target.isGlobalHint()) {
2407 VLOG(1) <<
"Skip the given query hint \"overlaps_keys_per_bin\" ("
2408 << overlaps_keys_per_bin
2409 <<
") : the hint value should be larger than zero";
2415 VLOG(1) <<
"Skip query hint \'keep_result\' because neither data recycler "
2416 "nor query resultset recycler is enabled";
2420 if (target.isGlobalHint()) {
2429 VLOG(1) <<
"Skip query hint \'keep_table_function_result\' because neither "
2431 "nor query resultset recycler is enabled";
2440 CHECK_EQ(1u, target.getListOptions().size());
2441 int aggregate_tree_fanout = std::stoi(target.getListOptions()[0]);
2442 if (aggregate_tree_fanout < 0) {
2443 VLOG(1) <<
"A fan-out of an aggregate tree should be larger than zero";
2444 }
else if (aggregate_tree_fanout > 1024) {
2445 VLOG(1) <<
"Too large fanout is provided (i.e., fanout < 1024)";
2449 if (target.isGlobalHint()) {
2471 if (has_global_columnar_output_hint.has_value() &&
2472 has_global_rowwise_output_hint.has_value()) {
2474 <<
"Two hints 1) columnar output and 2) rowwise output are enabled together, "
2475 <<
"so skip them and use the runtime configuration "
2476 "\"g_enable_columnar_output\"";
2477 }
else if (has_global_columnar_output_hint.has_value() &&
2478 !has_global_rowwise_output_hint.has_value()) {
2480 VLOG(1) <<
"We already enable columnar output by default "
2481 "(g_enable_columnar_output = true), so skip this columnar output hint";
2485 if (*has_global_columnar_output_hint) {
2490 }
else if (!has_global_columnar_output_hint.has_value() &&
2491 has_global_rowwise_output_hint.has_value()) {
2493 VLOG(1) <<
"We already use the default rowwise output (g_enable_columnar_output "
2494 "= false), so skip this rowwise output hint";
2498 if (*has_global_rowwise_output_hint) {
2504 auto node_key = node->toHash();
2507 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2508 hint_map.emplace(node->getId(), query_hint);
2511 it->second.emplace(node->getId(), query_hint);
2518 auto const& registered_query_hint_map = node_it->second;
2519 auto hint_it = registered_query_hint_map.find(node->
getId());
2520 if (hint_it != registered_query_hint_map.end()) {
2521 auto const& registered_query_hint = hint_it->second;
2524 return std::make_optional(registered_query_hint ||
global_hints_);
2526 return std::make_optional(registered_query_hint);
2535 return std::nullopt;
2538 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2557 std::vector<std::shared_ptr<RelAlgNode>>
nodes_;
2562 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>
2579 return rel_alg_dag.
nodes_;
2587 static std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2612 static std::unique_ptr<RelAlgDag>
buildDag(
const std::string& query_ra,
2614 const bool optimize_dag);
2626 const rapidjson::Value& query_ast,
2632 static std::unique_ptr<RelAlgDag>
build(
const rapidjson::Value& query_ast,
2635 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_
const RexScalar * getThen(const size_t idx) 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
const std::shared_ptr< const RelAlgNode > ra_
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()
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)
RelCompound(std::unique_ptr< const RexScalar > &filter_expr, const std::vector< const Rex * > &target_exprs, const size_t groupby_count, const std::vector< const RexAgg * > &agg_exprs, const std::vector< std::string > &fields, std::vector< std::unique_ptr< const RexScalar >> &scalar_sources, const bool is_agg, bool update_disguised_as_select=false, bool delete_disguised_as_select=false, bool varlen_update_required=false, TableDescriptor const *manipulation_target_table=nullptr, ColumnNameList target_columns=ColumnNameList())
static thread_local unsigned crt_id_
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
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
const JoinType join_type_
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
const SqlWindowFunctionKind kind_
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
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()
const boost::variant< int64_t, double, std::string, bool, void * > literal_
std::string getFieldName(const size_t idx) const
const RexScalar * getCondition() const
std::shared_ptr< std::shared_ptr< const ExecutionResult > > result_
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
const std::vector< TargetMetaInfo > tuple_type_
RexSubQuery(std::shared_ptr< SQLTypeInfo > type, std::shared_ptr< std::shared_ptr< const ExecutionResult >> result, const std::shared_ptr< const RelAlgNode > ra)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::optional< size_t > getIdInPlanTree() const
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
const RexScalar * getWhen(const size_t idx) const
const RegisteredQueryHint & getGlobalHints() const
double overlaps_keys_per_bin
void setFields(std::vector< std::string > &&fields)
void setFilterExpr(std::unique_ptr< const RexScalar > &new_expr)
std::vector< const Analyzer::ColumnVar * > getJoinCols(bool lhs) const
void appendInput(std::string new_field_name, std::unique_ptr< const RexScalar > new_input)
const RexScalar * getCondition() const
std::string getOpType() const
std::string query_plan_dag_
std::shared_ptr< RelAlgNode > deepCopy() const override
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
void checkForMatchingMetaInfoTypes() const
std::vector< std::unique_ptr< const RexScalar > > scalar_sources_
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
bool isCurrentRow() const
virtual std::unique_ptr< const RexOperator > getDisambiguated(std::vector< std::unique_ptr< const RexScalar >> &operands) const
size_t toHash() const override
const std::string getFieldName(const size_t i) const
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > & getQueryHints()
void clearContextData() const
TableDescriptor const *const getTableDescriptor() const
const size_t groupby_count_
std::shared_ptr< const RelAlgNode > getRootNodeShPtr() const
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)
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
const RexWindowBound frame_end_bound_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t getRowsSize() const
size_t getColInputsSize() const
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
void setDeleteViaSelectFlag() const
void setIdInPlanTree(size_t id) const
This file contains the class specification and related data structures for 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
const unsigned precision_
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
std::shared_ptr< const RelAlgNode > RelAlgNodeInputPtr
const RexScalar * getCondition() const
bool keep_table_function_result
std::shared_ptr< RelAlgNode > deepCopy() const override
const RexScalar * getTableFuncInputAtAndRelease(const size_t idx)
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
const NullSortedPosition nulls_pos_
const std::vector< RowValues > values_
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)
size_t toHash() const override
Hints * getDeliveredHints()
std::vector< std::string > fields_
static std::unique_ptr< RelAlgDag > build(const rapidjson::Value &query_ast, const Catalog_Namespace::Catalog &cat, RelAlgDag *root_dag, const bool optimize_dag)
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_
const std::vector< std::shared_ptr< const RelJoin > > original_joins_
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_
const size_t groupby_count_
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
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< RelAlgNode > deepCopy() const override
std::unique_ptr< Hints > hints_
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
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
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< 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 replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
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
static std::unique_ptr< RelAlgDag > buildDag(const std::string &query_ra, const Catalog_Namespace::Catalog &cat, const bool optimize_dag)
bool isRowOffsetFollowing() const
const std::vector< SortField > collation_
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_
void setCollation(std::vector< SortField > &&collation)
int32_t countRexLiteralArgs() const
std::unique_ptr< Hints > hints_
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_
const std::vector< const Rex * > target_exprs_
void addHint(const ExplainedQueryHint &hint_explained)
void setTableFuncInputs(std::vector< std::unique_ptr< const RexScalar >> &exprs)
const RexScalar * getOuterJoinCond() const
const RexWindowBound frame_start_bound_
bool hasNoFraming() const
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
std::vector< RexLiteral > RexLiteralArray
RelLogicalUnion(RelAlgInputs, bool is_all)
void registerSubquery(std::shared_ptr< RexSubQuery > subquery)
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
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
auto const isDeleteViaSelect() const
void setExecutionResult(const std::shared_ptr< const ExecutionResult > result)
bool operator==(const RelSort &that) const
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)
const SQLTypes target_type_
std::unique_ptr< const RexScalar > condition_
void replaceOperands(std::vector< std::unique_ptr< const RexScalar >> &&new_operands)
const std::vector< std::string > field_names_
RelLeftDeepInnerJoin(const std::shared_ptr< RelFilter > &filter, RelAlgInputs inputs, std::vector< std::shared_ptr< const RelJoin >> &original_joins)
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
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const SortDirection sort_dir_
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
RelProject(std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs, const std::vector< std::string > &fields, std::shared_ptr< const RelAlgNode > input)
auto const isUpdateViaSelect() const
const std::string op_typeinfo_
void setOutputMetainfo(const std::vector< TargetMetaInfo > &targets_metainfo) const
SQLTypes getTargetType() const
ConstRexScalarPtrVector partition_keys_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
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
RegisteredQueryHint global_hints_
std::shared_ptr< RelAlgNode > deepCopy() const override
const std::vector< size_t > operands_
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
const unsigned target_precision_
std::shared_ptr< RelAlgNode > deepCopy() const override
const std::shared_ptr< RelFilter > original_filter_
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
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())
RexLiteral(const SQLTypes target_type)
QueryNotSupported(const std::string &reason)
const unsigned target_scale_
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
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
void setUpdateViaSelectFlag() const
RelScan(const TableDescriptor *td, const std::vector< std::string > &field_names)
size_t size() const override
const std::vector< TargetMetaInfo > & getOutputMetainfo() const
const TableDescriptor * getTableDescriptor() const
static std::unique_ptr< RelAlgDag > buildDagForSubquery(RelAlgDag &root_dag, const rapidjson::Value &query_ast, const Catalog_Namespace::Catalog &cat)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
std::shared_ptr< const ExecutionResult > getExecutionResult() const
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
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
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)
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)
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()
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