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;
381 return *
reinterpret_cast<const size_t*
>(may_alias_ptr(&addr)) ^ rex_in.
getIndex();
391 RexCase(std::vector<std::pair<std::unique_ptr<const RexScalar>,
392 std::unique_ptr<const RexScalar>>>& expr_pair_list,
393 std::unique_ptr<const RexScalar>& else_expr)
412 auto ret =
cat(::
typeName(
this),
"(expr_pair_list=");
414 ret += expr.first->toString(config) +
" " + expr.second->toString(config) +
" ";
434 std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
450 std::vector<std::unique_ptr<const RexScalar>>& operands)
const override {
451 return std::unique_ptr<const RexOperator>(
461 ret += operand->toString(config) +
" ";
463 return cat(ret,
")");
472 boost::hash_combine(*
hash_, operand->toHash());
517 auto hash = boost::hash_value(
field_);
544 const std::vector<SortField> collation,
573 std::unique_ptr<const RexScalar>&& new_partition_key) {
578 void replaceOrderKey(
size_t offset, std::unique_ptr<const RexScalar>&& new_order_key) {
599 const std::vector<SortField>& collation)
const {
600 return std::unique_ptr<const RexOperator>(
616 ret += operand->toString(config) +
" ";
618 ret +=
", partition_keys=";
620 ret += key->toString(config) +
" ";
622 ret +=
", order_keys=";
624 ret += key->toString(config) +
" ";
626 return cat(ret,
")");
636 boost::hash_combine(*
hash_, collation.toHash());
639 boost::hash_combine(*
hash_, operand->toHash());
642 boost::hash_combine(*
hash_, key->toHash());
645 boost::hash_combine(*
hash_, key->toHash());
647 auto get_window_bound_hash =
649 auto h = boost::hash_value(bound.offset ? bound.offset->toHash() :
HASH_N);
650 boost::hash_combine(h, bound.unbounded);
651 boost::hash_combine(h, bound.preceding);
652 boost::hash_combine(h, bound.following);
653 boost::hash_combine(h, bound.is_current_row);
654 boost::hash_combine(h, bound.order_key);
694 std::unique_ptr<RexRef>
deepCopy()
const {
return std::make_unique<RexRef>(
index_); }
705 const std::vector<size_t>& operands)
726 boost::hash_combine(*
hash_, operand);
786 if (!extracted_query_plan_dag.empty()) {
827 for (
auto& input_ptr :
inputs_) {
828 if (input_ptr.get() == needle) {
836 std::shared_ptr<const RelAlgNode> input) {
837 for (
auto& input_ptr :
inputs_) {
838 if (input_ptr == old_input) {
857 virtual size_t toHash()
const = 0;
859 virtual size_t size()
const = 0;
861 virtual std::shared_ptr<RelAlgNode>
deepCopy()
const = 0;
875 mutable std::optional<size_t>
hash_;
923 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
963 bool const delete_via_select =
false,
964 bool const varlen_update_required =
false,
995 template <
typename VALIDATION_FUNCTOR>
998 if (validator(column_name) ==
false) {
1021 RelProject(std::vector<std::unique_ptr<const RexScalar>>& scalar_exprs,
1022 const std::vector<std::string>& fields,
1023 std::shared_ptr<const RelAlgNode> input)
1043 if (!dynamic_cast<const RexInput*>(expr.get())) {
1076 std::shared_ptr<const RelAlgNode> input)
override {
1081 std::shared_ptr<const RelAlgNode> old_input,
1082 std::shared_ptr<const RelAlgNode> input,
1083 std::optional<std::unordered_map<unsigned, unsigned>> old_to_new_index_map);
1086 std::unique_ptr<const RexScalar> new_input);
1092 ret += expr->toString(config) +
" ";
1101 boost::hash_combine(*
hash_, target_expr->toHash());
1108 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1109 return std::make_shared<RelProject>(*this);
1140 template <
typename EXPR_VISITOR_FUNCTOR>
1142 for (
int i = 0; i < static_cast<int>(
scalar_exprs_.size()); i++) {
1150 std::make_unique<RexFunctionOperator const>(std::string(
"OFFSET_IN_FRAGMENT"),
1153 fields_.emplace_back(
"EXPR$DELETE_OFFSET_IN_FRAGMENT");
1166 std::vector<std::unique_ptr<const RexAgg>>& agg_exprs,
1167 const std::vector<std::string>& fields,
1168 std::shared_ptr<const RelAlgNode> input)
1187 fields_ = std::move(new_fields);
1193 std::vector<const RexAgg*>
result;
1195 result.push_back(agg_expr.release());
1204 const std::vector<std::unique_ptr<const RexAgg>>&
getAggExprs()
const {
1208 void setAggExprs(std::vector<std::unique_ptr<const RexAgg>>& agg_exprs) {
1221 if (!config.skip_input_nodes) {
1224 ret +=
", input node id={";
1226 auto node_id_in_plan = input->getIdInPlanTree();
1227 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1229 ret += node_id_str +
" ";
1233 return cat(ret,
")");
1241 boost::hash_combine(*
hash_, agg_expr->toHash());
1244 boost::hash_combine(*
hash_, node->toHash());
1251 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1252 return std::make_shared<RelAggregate>(*this);
1291 std::shared_ptr<const RelAlgNode> rhs,
1292 std::unique_ptr<const RexScalar>& condition,
1315 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1316 std::shared_ptr<const RelAlgNode> input)
override;
1321 if (!config.skip_input_nodes) {
1324 ret +=
", input node id={";
1326 auto node_id_in_plan = input->getIdInPlanTree();
1327 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1329 ret += node_id_str +
" ";
1345 boost::hash_combine(*
hash_, node->toHash());
1354 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1355 return std::make_shared<RelJoin>(*this);
1396 const std::vector<const Analyzer::ColumnVar*> lhs_join_cols,
1397 const std::vector<const Analyzer::ColumnVar*> rhs_join_cols,
1398 const std::vector<std::shared_ptr<const Analyzer::Expr>> filter_ops,
1400 const bool nested_loop,
1402 const std::string& op_type,
1403 const std::string& qualifier,
1404 const std::string& op_typeinfo)
1420 "( join_quals { lhs: ",
1424 " }, filter_quals: { ",
1426 " }, outer_join_cond: { ",
1452 boost::hash_combine(*
hash_, filter_op->toString());
1460 const std::vector<std::shared_ptr<const Analyzer::Expr>>
getFilterCond()
const {
1467 size_t size()
const override {
return 0; }
1479 std::shared_ptr<const RelAlgNode> input)
override {
1482 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1512 std::shared_ptr<const RelAlgNode> input)
1513 :
filter_(std::move(filter)) {
1531 filter_ = std::move(condition);
1536 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1537 std::shared_ptr<const RelAlgNode> input)
override;
1543 if (!config.skip_input_nodes) {
1546 ret +=
", input node id={";
1548 auto node_id_in_plan = input->getIdInPlanTree();
1549 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1551 ret += node_id_str +
" ";
1555 return cat(ret,
")");
1563 boost::hash_combine(*
hash_, node->toHash());
1569 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1570 return std::make_shared<RelFilter>(*this);
1582 std::vector<std::shared_ptr<const RelJoin>>& original_joins);
1593 size_t toHash()
const override;
1595 size_t size()
const override;
1597 std::shared_ptr<RelAlgNode>
deepCopy()
const override;
1622 const std::vector<const Rex*>& target_exprs,
1623 const size_t groupby_count,
1624 const std::vector<const RexAgg*>& agg_exprs,
1625 const std::vector<std::string>& fields,
1626 std::vector<std::unique_ptr<const RexScalar>>& scalar_sources,
1628 bool update_disguised_as_select =
false,
1629 bool delete_disguised_as_select =
false,
1630 bool varlen_update_required =
false,
1634 delete_disguised_as_select,
1635 varlen_update_required,
1636 manipulation_target_table,
1646 CHECK_EQ(fields.size(), target_exprs.size());
1647 for (
auto agg_expr : agg_exprs) {
1654 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
1655 std::shared_ptr<const RelAlgNode> input)
override;
1695 size_t toHash()
const override;
1697 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1698 return std::make_shared<RelCompound>(*this);
1732 std::vector<std::unique_ptr<const RexScalar>>
1744 const size_t offset,
1745 std::shared_ptr<const RelAlgNode> input,
1746 bool limit_delivered)
1794 if (!config.skip_input_nodes) {
1797 ret +=
", input node id={";
1799 auto node_id_in_plan = input->getIdInPlanTree();
1800 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1802 ret += node_id_str +
" ";
1806 return cat(ret,
")");
1813 boost::hash_combine(*
hash_, collation.toHash());
1822 boost::hash_combine(*
hash_, node->toHash());
1830 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1831 return std::make_shared<RelSort>(*this);
1861 throw std::runtime_error(
"Unexpected ModifyOperation enum encountered.");
1865 if (op_string ==
"INSERT") {
1867 }
else if (op_string ==
"DELETE") {
1869 }
else if (op_string ==
"UPDATE") {
1873 throw std::runtime_error(
1874 std::string(
"Unsupported logical modify operation encountered " + op_string));
1880 std::string
const& op_string,
1913 size_t size()
const override {
return 0; }
1914 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
1915 return std::make_shared<RelModify>(*this);
1927 ", target_column_list=",
1929 if (!config.skip_input_nodes) {
1932 ret +=
", input node id={";
1934 auto node_id_in_plan = input->getIdInPlanTree();
1935 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
1937 ret += node_id_str +
" ";
1941 return cat(ret,
")");
1952 boost::hash_combine(*
hash_, node->toHash());
1961 CHECK(previous_project_node !=
nullptr);
1964 throw std::runtime_error(
1965 "UPDATE of a column using a window function is not currently supported.");
1975 int target_update_column_expr_start = 0;
1977 CHECK(target_update_column_expr_start >= 0);
1978 CHECK(target_update_column_expr_end >= 0);
1980 bool varlen_update_required =
false;
1982 auto varlen_scan_visitor = [
this,
1983 &varlen_update_required,
1984 target_update_column_expr_start,
1985 target_update_column_expr_end](
int index) {
1986 if (index >= target_update_column_expr_start &&
1987 index <= target_update_column_expr_end) {
1988 auto target_index = index - target_update_column_expr_start;
1995 const auto shard_cd =
1998 if ((column_desc->columnName == shard_cd->columnName)) {
1999 throw std::runtime_error(
"UPDATE of a shard key is currently unsupported.");
2004 if (column_desc->columnType.is_varlen()) {
2005 varlen_update_required =
true;
2007 if (column_desc->columnType.is_geometry()) {
2008 throw std::runtime_error(
"UPDATE of a geo column is unsupported.");
2020 CHECK(previous_project_node !=
nullptr);
2037 std::vector<std::string>& fields,
2038 std::vector<const Rex*> col_inputs,
2039 std::vector<std::unique_ptr<const RexScalar>>& table_func_inputs,
2040 std::vector<std::unique_ptr<const RexScalar>>& target_exprs)
2046 for (
const auto& input : inputs) {
2053 void replaceInput(std::shared_ptr<const RelAlgNode> old_input,
2054 std::shared_ptr<const RelAlgNode> input)
override;
2093 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2094 return std::make_shared<RelTableFunction>(*this);
2100 if (!config.skip_input_nodes) {
2103 ret +=
", input node id={";
2105 auto node_id_in_plan = input->getIdInPlanTree();
2106 auto node_id_str = node_id_in_plan ?
std::to_string(*node_id_in_plan)
2108 ret += node_id_str +
" ";
2114 if (!config.skip_input_nodes) {
2118 ret += expr->toString(config) +
" ";
2121 ret +=
", target_exprs=";
2123 ret += expr->toString(config) +
" ";
2125 return cat(ret,
")");
2132 boost::hash_combine(*
hash_, table_func_input->toHash());
2135 boost::hash_combine(*
hash_, target_expr->toHash());
2140 boost::hash_combine(*
hash_, node->toHash());
2150 std::vector<const Rex*>
2155 std::vector<std::unique_ptr<const RexScalar>>
2162 using RowValues = std::vector<std::unique_ptr<const RexScalar>>;
2165 std::vector<RowValues>& values)
2175 for (
const auto& target_meta_info :
tuple_type_) {
2176 ret +=
" (" + target_meta_info.get_resname() +
" " +
2177 target_meta_info.get_type_info().get_type_name() +
")";
2187 boost::hash_combine(*
hash_, target_meta_info.get_resname());
2188 boost::hash_combine(*
hash_, target_meta_info.get_type_info().get_type_name());
2196 const auto& row =
values_[row_idx];
2198 return row[col_idx].get();
2205 return values_.front().size();
2215 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2216 return std::make_shared<RelLogicalValues>(*this);
2227 std::shared_ptr<RelAlgNode>
deepCopy()
const override {
2228 return std::make_shared<RelLogicalUnion>(*this);
2230 size_t size()
const override;
2233 size_t toHash()
const override;
2287 const rapidjson::Value& query_ast,
2298 const auto& last_ptr =
nodes_.back();
2325 Hints* hints_delivered,
2327 std::optional<bool> has_global_columnar_output_hint = std::nullopt;
2328 std::optional<bool> has_global_rowwise_output_hint = std::nullopt;
2330 for (
auto it = hints_delivered->begin(); it != hints_delivered->end(); it++) {
2331 auto target = it->second;
2332 auto hint_type = it->first;
2333 switch (hint_type) {
2337 if (target.isGlobalHint()) {
2344 has_global_columnar_output_hint = target.isGlobalHint();
2348 has_global_rowwise_output_hint = target.isGlobalHint();
2352 CHECK(target.getListOptions().size() == 1);
2353 double overlaps_bucket_threshold = std::stod(target.getListOptions()[0]);
2354 if (overlaps_bucket_threshold >= 0.0 && overlaps_bucket_threshold <= 90.0) {
2357 if (target.isGlobalHint()) {
2362 VLOG(1) <<
"Skip the given query hint \"overlaps_bucket_threshold\" ("
2363 << overlaps_bucket_threshold
2364 <<
") : the hint value should be within 0.0 ~ 90.0";
2369 CHECK(target.getListOptions().size() == 1);
2370 std::stringstream ss(target.getListOptions()[0]);
2371 int overlaps_max_size;
2372 ss >> overlaps_max_size;
2373 if (overlaps_max_size >= 0) {
2376 if (target.isGlobalHint()) {
2381 VLOG(1) <<
"Skip the query hint \"overlaps_max_size\" (" << overlaps_max_size
2382 <<
") : the hint value should be larger than or equal to zero";
2389 if (target.isGlobalHint()) {
2398 if (target.isGlobalHint()) {
2402 VLOG(1) <<
"Skip auto tuner and hashtable caching for overlaps join.";
2406 CHECK(target.getListOptions().size() == 1);
2407 double overlaps_keys_per_bin = std::stod(target.getListOptions()[0]);
2408 if (overlaps_keys_per_bin > 0.0 &&
2409 overlaps_keys_per_bin < std::numeric_limits<double>::max()) {
2412 if (target.isGlobalHint()) {
2417 VLOG(1) <<
"Skip the given query hint \"overlaps_keys_per_bin\" ("
2418 << overlaps_keys_per_bin
2419 <<
") : the hint value should be larger than zero";
2425 VLOG(1) <<
"Skip query hint \'keep_result\' because neither data recycler "
2426 "nor query resultset recycler is enabled";
2430 if (target.isGlobalHint()) {
2439 VLOG(1) <<
"Skip query hint \'keep_table_function_result\' because neither "
2441 "nor query resultset recycler is enabled";
2464 if (has_global_columnar_output_hint.has_value() &&
2465 has_global_rowwise_output_hint.has_value()) {
2467 <<
"Two hints 1) columnar output and 2) rowwise output are enabled together, "
2468 <<
"so skip them and use the runtime configuration "
2469 "\"g_enable_columnar_output\"";
2470 }
else if (has_global_columnar_output_hint.has_value() &&
2471 !has_global_rowwise_output_hint.has_value()) {
2473 VLOG(1) <<
"We already enable columnar output by default "
2474 "(g_enable_columnar_output = true), so skip this columnar output hint";
2478 if (*has_global_columnar_output_hint) {
2483 }
else if (!has_global_columnar_output_hint.has_value() &&
2484 has_global_rowwise_output_hint.has_value()) {
2486 VLOG(1) <<
"We already use the default rowwise output (g_enable_columnar_output "
2487 "= false), so skip this rowwise output hint";
2491 if (*has_global_rowwise_output_hint) {
2497 auto node_key = node->toHash();
2500 std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2501 hint_map.emplace(node->getId(), query_hint);
2504 it->second.emplace(node->getId(), query_hint);
2511 auto const& registered_query_hint_map = node_it->second;
2512 auto hint_it = registered_query_hint_map.find(node->
getId());
2513 if (hint_it != registered_query_hint_map.end()) {
2514 auto const& registered_query_hint = hint_it->second;
2517 return std::make_optional(registered_query_hint ||
global_hints_);
2519 return std::make_optional(registered_query_hint);
2528 return std::nullopt;
2531 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>&
2551 std::vector<std::shared_ptr<RelAlgNode>>
nodes_;
2557 std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint>>
std::vector< std::shared_ptr< const RexScalar > > scalar_exprs_
DEVICE auto upper_bound(ARGS &&...args)
std::shared_ptr< RelAlgNode > deepCopy() const override
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
const size_t getGroupByCount() const
virtual std::string toString(RelRexToStringConfig config) const =0
std::shared_ptr< const RelAlgNode > getRootNodeShPtr() 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
std::shared_ptr< RelAlgNode > deepCopy() const override
int getUpdateColumnCount() const
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
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
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > & getQueryHints()
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 RexWindowBound upper_bound_
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
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
void build(const rapidjson::Value &query_ast, RelAlgDagBuilder &root_dag_builder)
const RexScalar * getCondition() const
std::shared_ptr< std::shared_ptr< const ExecutionResult > > result_
const std::vector< std::shared_ptr< RexSubQuery > > & getSubqueries() const
RexSubQuery & operator=(const RexSubQuery &)=delete
std::unique_ptr< const RexScalar > else_expr_
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
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_
const Catalog_Namespace::Catalog & cat_
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
const RaExecutionDesc * context_data_
std::shared_ptr< const RelAlgNode > getAndOwnInput(const size_t idx) 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
void clearContextData() const
TableDescriptor const *const getTableDescriptor() const
const size_t groupby_count_
const std::string getFieldName(const size_t i) const
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
size_t getQueryPlanDagHash() const
const std::string qualifier_
std::vector< SortField > collation_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t getRowsSize() const
size_t getColInputsSize() const
const ExplainedQueryHint & getHintInfo(QueryHint hint) const
std::vector< RexLiteral > RexLiteralArray
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
std::vector< std::shared_ptr< RexSubQuery > > subqueries_
void setExpressions(std::vector< std::unique_ptr< const RexScalar >> &exprs) const
const RenderInfo * render_info_
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
void registerQueryHints(std::shared_ptr< RelAlgNode > node, Hints *hints_delivered, RegisteredQueryHint &global_query_hint)
size_t toHash() const override
bool is_delete_via_select_
SQLOps getOperator() const
std::vector< std::shared_ptr< RelAlgNode > > nodes_
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::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
void resetQueryExecutionState()
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_
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::shared_ptr< const RexScalar > offset
std::unique_ptr< Hints > hints_
std::vector< std::unique_ptr< const RexScalar > > scalar_exprs_
void registerHint(const QueryHint hint)
std::shared_ptr< RelAlgNode > deepCopy() const override
RegisteredQueryHint global_hints_
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_
const RelAlgNode & getRootNode() const
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
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
void eachNode(std::function< void(RelAlgNode const *)> const &) 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
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
RexWindowFunctionOperator(const SqlWindowFunctionKind kind, ConstRexScalarPtrVector &operands, ConstRexScalarPtrVector &partition_keys, ConstRexScalarPtrVector &order_keys, const std::vector< SortField > collation, const RexWindowBound &lower_bound, const RexWindowBound &upper_bound, const bool is_rows, const SQLTypeInfo &ti)
const RexScalar * getProjectAt(const size_t idx) const
std::vector< std::shared_ptr< const RelAlgNode >> RelAlgInputs
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 RexWindowBound & getLowerBound() const
const RelAlgNode * getLHS() const
std::string tree_string(const RelAlgNode *ra, const size_t depth)
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
DEVICE auto lower_bound(ARGS &&...args)
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
void replaceInput(std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override
RelLogicalUnion(RelAlgInputs, bool is_all)
std::vector< std::unique_ptr< const RexAgg > > agg_exprs_
static RelRexToStringConfig defaults()
SortField(const size_t field, const SortDirection sort_dir, const NullSortedPosition nulls_pos)
std::unique_ptr< const RexScalar > filter_expr_
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 registerSubquery(std::shared_ptr< RexSubQuery > subquery)
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)
RelAlgDagBuilder()=delete
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 RexWindowBound & getUpperBound() const
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::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
const RexScalar * getValueAt(const size_t row_idx, const size_t col_idx) const
size_t toHash() const override
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
RANodeOutput get_node_output(const RelAlgNode *ra_node)
ConstRexScalarPtrVector partition_keys_
std::string toString(RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
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)
std::vector< RexLiteralArray > TupleContentsArray
const RexAgg * getAggExpr(size_t i) const
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_
const RegisteredQueryHint & getGlobalHints() const
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::vector< std::string > ColumnNameList
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< RexInput > RANodeOutput
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)
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 RexWindowBound lower_bound_
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
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
void setGlobalQueryHints(const RegisteredQueryHint &global_hints)
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
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)
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 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()
std::optional< RegisteredQueryHint > getQueryHint(const RelAlgNode *node) const
size_t toHash() const override
bool validateTargetColumns(VALIDATION_FUNCTOR validator) const
static void resetRelAlgFirstId() noexcept