#include "RelAlgDag.h"
#include "CalciteDeserializerUtils.h"
#include "Catalog/Catalog.h"
#include "Descriptors/RelAlgExecutionDescriptor.h"
#include "JsonAccessors.h"
#include "QueryEngine/Visitors/RelAlgDagViewer.h"
#include "RelAlgOptimizer.h"
#include "RelLeftDeepInnerJoin.h"
#include "RexVisitor.h"
#include "Shared/sqldefs.h"
#include <rapidjson/error/en.h>
#include <rapidjson/error/error.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/writer.h>
#include <string>
#include <unordered_set>

Include dependency graph for RelAlgDag.cpp:

Classes
class	anonymous_namespace{RelAlgDag.cpp}::RexRebindInputsVisitor

class	anonymous_namespace{RelAlgDag.cpp}::RexRebindReindexInputsVisitor

class	anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction

struct	std::hash< std::pair< const RelAlgNode *, int > >

class	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::RexInputReplacementVisitor

class	anonymous_namespace{RelAlgDag.cpp}::RANodeIterator

class	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::CoalesceSecondaryProjectVisitor

class	anonymous_namespace{RelAlgDag.cpp}::WindowFunctionCollector

class	anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor

class	anonymous_namespace{RelAlgDag.cpp}::RexInputCollector

class	details::RelAlgDispatcher

Namespaces
	anonymous_namespace{RelAlgDag.cpp}

	std

	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}

	details

Typedefs
using	anonymous_namespace{RelAlgDag.cpp}::RexInputSet = std::unordered_set< RexInput >

Functions
std::vector< RexInput >	anonymous_namespace{RelAlgDag.cpp}::n_outputs (const RelAlgNode *node, const size_t n)

RANodeOutput	get_node_output (const RelAlgNode *ra_node)

bool	anonymous_namespace{RelAlgDag.cpp}::isRenamedInput (const RelAlgNode *node, const size_t index, const std::string &new_name)

std::vector< std::unique_ptr < const RexAgg > >	anonymous_namespace{RelAlgDag.cpp}::copyAggExprs (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs)

std::vector< std::unique_ptr < const RexScalar > >	anonymous_namespace{RelAlgDag.cpp}::copyRexScalars (std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources)

std::vector< const Rex * >	anonymous_namespace{RelAlgDag.cpp}::remapTargetPointers (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_new, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_new, std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_old, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_old, std::vector< const Rex * > const &target_exprs_old)

void	anonymous_namespace{RelAlgDag.cpp}::reset_table_function_inputs (std::vector< const Rex * > &column_inputs, const std::vector< std::unique_ptr< const RexScalar >> &old_table_func_inputs, const std::vector< std::unique_ptr< const RexScalar >> &new_table_func_inputs)

std::set< std::pair< const RelAlgNode *, int > >	anonymous_namespace{RelAlgDag.cpp}::get_equiv_cols (const RelAlgNode *node, const size_t which_col)

std::vector< bool >	anonymous_namespace{RelAlgDag.cpp}::get_notnulls (std::vector< TargetMetaInfo > const &tmis0)

bool	anonymous_namespace{RelAlgDag.cpp}::same_ignoring_notnull (SQLTypeInfo ti0, SQLTypeInfo ti1)

void	anonymous_namespace{RelAlgDag.cpp}::set_notnulls (std::vector< TargetMetaInfo > *tmis0, std::vector< bool > const &notnulls)

unsigned	anonymous_namespace{RelAlgDag.cpp}::node_id (const rapidjson::Value &ra_node) noexcept

std::string	anonymous_namespace{RelAlgDag.cpp}::json_node_to_string (const rapidjson::Value &node) noexcept

std::unique_ptr< RexAbstractInput >	anonymous_namespace{RelAlgDag.cpp}::parse_abstract_input (const rapidjson::Value &expr) noexcept

std::unique_ptr< RexLiteral >	anonymous_namespace{RelAlgDag.cpp}::parse_literal (const rapidjson::Value &expr)

std::unique_ptr< const RexScalar >	anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr (const rapidjson::Value &expr, RelAlgDag &root_dag)

SQLTypeInfo	anonymous_namespace{RelAlgDag.cpp}::parse_type (const rapidjson::Value &type_obj)

std::vector< std::unique_ptr < const RexScalar > >	anonymous_namespace{RelAlgDag.cpp}::parse_expr_array (const rapidjson::Value &arr, RelAlgDag &root_dag)

SqlWindowFunctionKind	anonymous_namespace{RelAlgDag.cpp}::parse_window_function_kind (const std::string &name)

std::vector< std::unique_ptr < const RexScalar > >	anonymous_namespace{RelAlgDag.cpp}::parse_window_order_exprs (const rapidjson::Value &arr, RelAlgDag &root_dag)

SortDirection	anonymous_namespace{RelAlgDag.cpp}::parse_sort_direction (const rapidjson::Value &collation)

NullSortedPosition	anonymous_namespace{RelAlgDag.cpp}::parse_nulls_position (const rapidjson::Value &collation)

std::vector< SortField >	anonymous_namespace{RelAlgDag.cpp}::parse_window_order_collation (const rapidjson::Value &arr, RelAlgDag &root_dag)

RexWindowFunctionOperator::RexWindowBound	anonymous_namespace{RelAlgDag.cpp}::parse_window_bound (const rapidjson::Value &window_bound_obj, RelAlgDag &root_dag)

std::unique_ptr< const RexSubQuery >	anonymous_namespace{RelAlgDag.cpp}::parse_subquery (const rapidjson::Value &expr, RelAlgDag &root_dag)

std::unique_ptr< RexOperator >	anonymous_namespace{RelAlgDag.cpp}::parse_operator (const rapidjson::Value &expr, RelAlgDag &root_dag)

std::unique_ptr< RexCase >	anonymous_namespace{RelAlgDag.cpp}::parse_case (const rapidjson::Value &expr, RelAlgDag &root_dag)

std::vector< std::string >	anonymous_namespace{RelAlgDag.cpp}::strings_from_json_array (const rapidjson::Value &json_str_arr) noexcept

std::vector< size_t >	anonymous_namespace{RelAlgDag.cpp}::indices_from_json_array (const rapidjson::Value &json_idx_arr) noexcept

std::unique_ptr< const RexAgg >	anonymous_namespace{RelAlgDag.cpp}::parse_aggregate_expr (const rapidjson::Value &expr)

JoinType	anonymous_namespace{RelAlgDag.cpp}::to_join_type (const std::string &join_type_name)

std::unique_ptr< const RexScalar >	anonymous_namespace{RelAlgDag.cpp}::disambiguate_rex (const RexScalar *, const RANodeOutput &)

std::unique_ptr< const RexOperator >	anonymous_namespace{RelAlgDag.cpp}::disambiguate_operator (const RexOperator *rex_operator, const RANodeOutput &ra_output) noexcept

std::unique_ptr< const RexCase >	anonymous_namespace{RelAlgDag.cpp}::disambiguate_case (const RexCase *rex_case, const RANodeOutput &ra_output)

void	anonymous_namespace{RelAlgDag.cpp}::bind_project_to_input (RelProject *project_node, const RANodeOutput &input) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::bind_table_func_to_input (RelTableFunction *table_func_node, const RANodeOutput &input) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::bind_inputs (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::handle_query_hint (const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDag &rel_alg_dag) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::compute_node_hash (const std::vector< std::shared_ptr< RelAlgNode >> &nodes)

void	anonymous_namespace{RelAlgDag.cpp}::mark_nops (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept

std::vector< const Rex * >	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::reproject_targets (const RelProject simple_project, const std::vector< const Rex > &target_exprs) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::create_compound (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< size_t > &pattern, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints) noexcept

bool	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::input_can_be_coalesced (const RelAlgNode *parent_node, const size_t index, const bool first_rex_is_input)

bool	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_sum (const RexScalar *rex)

bool	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_avg (const RexScalar *rex)

bool	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_operator (const RexScalar *rex)

void	anonymous_namespace{RelAlgDag.cpp}::coalesce_nodes (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< const RelAlgNode * > &left_deep_joins, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)

void	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::create_rex_input_for_new_project_node (RelAlgNode const *node, std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs, std::vector< std::string > &fields)

void	anonymous_namespace{RelAlgDag.cpp}::handle_agg_over_join (std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)

void	anonymous_namespace{RelAlgDag.cpp}::eliminate_redundant_projection (std::vector< std::shared_ptr< RelAlgNode >> &nodes)

void	anonymous_namespace{RelAlgDag.cpp}::propagate_hints_to_new_project (std::shared_ptr< RelProject > prev_node, std::shared_ptr< RelProject > new_node, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)

void	anonymous_namespace{RelAlgDag.cpp}::separate_window_function_expressions (std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)

bool	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::find_generic_expr_in_window_func (RexWindowFunctionOperator const *window_expr, bool &has_generic_expr_in_window_func)

std::pair< bool, bool >	anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::need_pushdown_generic_expr (RelProject const *window_func_project_node)

void	anonymous_namespace{RelAlgDag.cpp}::add_window_function_pre_project (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const bool always_add_project_if_first_project_is_window_expr, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)

int64_t	anonymous_namespace{RelAlgDag.cpp}::get_int_literal_field (const rapidjson::Value &obj, const char field[], const int64_t default_val) noexcept

void	anonymous_namespace{RelAlgDag.cpp}::check_empty_inputs_field (const rapidjson::Value &node) noexcept

const std::pair< const Catalog_Namespace::Catalog , const TableDescriptor >	anonymous_namespace{RelAlgDag.cpp}::getCatalogAndTableFromScanNode (const rapidjson::Value &scan_ra)

std::vector< std::string >	anonymous_namespace{RelAlgDag.cpp}::getFieldNamesFromScanNode (const rapidjson::Value &scan_ra)

std::string	tree_string (const RelAlgNode *ra, const size_t depth)

std::size_t	hash_value (RexAbstractInput const &rex_ab_input)

std::size_t	hash_value (RexLiteral const &rex_literal)

std::size_t	hash_value (RexOperator const &rex_op)

std::size_t	hash_value (RexCase const &rex_case)

std::size_t	hash_value (RexFunctionOperator const &rex_op)

std::size_t	hash_value (SortField const &sort_field)

std::size_t	hash_value (RexWindowFunctionOperator const &rex_window)

std::size_t	hash_value (RexRef const &rex_ref)

std::size_t	hash_value (RexAgg const &rex_agg)

std::size_t	hash_value (RexSubQuery const &rex_subq)

std::size_t	hash_value (RexInput const &rex_input)

std::size_t	hash_value (RelScan const &rel_scan)

std::size_t	hash_value (RelProject const &rel_project)

std::size_t	hash_value (RelAggregate const &rel_agg)

std::size_t	hash_value (RelJoin const &rel_join)

std::size_t	hash_value (RelTranslatedJoin const &rel_tr_join)

std::size_t	hash_value (RelFilter const &rel_filter)

std::size_t	hash_value (RelLeftDeepInnerJoin const &rel_join)

std::size_t	hash_value (RelCompound const &rel_compound)

std::size_t	hash_value (RelSort const &rel_sort)

std::size_t	hash_value (RelModify const &rel_modify)

std::size_t	hash_value (RelTableFunction const &rel_tf)

std::size_t	hash_value (RelLogicalValues const &rel_lv)

std::size_t	hash_value (RelLogicalUnion const &rel_lv)

Variables
bool	g_cluster

bool	g_enable_union

const unsigned	anonymous_namespace{RelAlgDag.cpp}::FIRST_RA_NODE_ID = 1

Function Documentation

RANodeOutput get_node_output ( const RelAlgNode * ra_node )

Definition at line 371 of file RelAlgDag.cpp.

References CHECK_EQ, logger::FATAL, get_node_output(), LOG, anonymous_namespace{RelAlgDag.cpp}::n_outputs(), and toString().

Referenced by anonymous_namespace{RelAlgDag.cpp}::bind_inputs(), anonymous_namespace{RelAlgDag.cpp}::create_compound(), anonymous_namespace{RelAlgExecutor.cpp}::get_left_deep_join_input_sizes(), get_node_output(), RelProject::isIdentity(), anonymous_namespace{QueryPhysicalInputsCollector.cpp}::RexPhysicalInputsVisitor::visitInput(), and anonymous_namespace{QueryPhysicalInputsCollector.cpp}::RexPhysicalInputsVisitor::visitOperator().

                                                         {
   const auto scan_node = dynamic_cast<const RelScan*>(ra_node);
   if (scan_node) {
     // Scan node has no inputs, output contains all columns in the table.
     CHECK_EQ(size_t(0), scan_node->inputCount());
     return n_outputs(scan_node, scan_node->size());
   }
   const auto project_node = dynamic_cast<const RelProject*>(ra_node);
   if (project_node) {
     // Project output count doesn't depend on the input
     CHECK_EQ(size_t(1), project_node->inputCount());
     return n_outputs(project_node, project_node->size());
   }
   const auto filter_node = dynamic_cast<const RelFilter*>(ra_node);
   if (filter_node) {
     // Filter preserves shape
     CHECK_EQ(size_t(1), filter_node->inputCount());
     const auto prev_out = get_node_output(filter_node->getInput(0));
     return n_outputs(filter_node, prev_out.size());
   }
   const auto aggregate_node = dynamic_cast<const RelAggregate*>(ra_node);
   if (aggregate_node) {
     // Aggregate output count doesn't depend on the input
     CHECK_EQ(size_t(1), aggregate_node->inputCount());
     return n_outputs(aggregate_node, aggregate_node->size());
   }
   const auto compound_node = dynamic_cast<const RelCompound*>(ra_node);
   if (compound_node) {
     // Compound output count doesn't depend on the input
     CHECK_EQ(size_t(1), compound_node->inputCount());
     return n_outputs(compound_node, compound_node->size());
   }
   const auto join_node = dynamic_cast<const RelJoin*>(ra_node);
   if (join_node) {
     // Join concatenates the outputs from the inputs and the output
     // directly references the nodes in the input.
     CHECK_EQ(size_t(2), join_node->inputCount());
     auto lhs_out =
         n_outputs(join_node->getInput(0), get_node_output(join_node->getInput(0)).size());
     const auto rhs_out =
         n_outputs(join_node->getInput(1), get_node_output(join_node->getInput(1)).size());
     lhs_out.insert(lhs_out.end(), rhs_out.begin(), rhs_out.end());
     return lhs_out;
   }
   const auto table_func_node = dynamic_cast<const RelTableFunction*>(ra_node);
   if (table_func_node) {
     // Table Function output count doesn't depend on the input
     return n_outputs(table_func_node, table_func_node->size());
   }
   const auto sort_node = dynamic_cast<const RelSort*>(ra_node);
   if (sort_node) {
     // Sort preserves shape
     CHECK_EQ(size_t(1), sort_node->inputCount());
     const auto prev_out = get_node_output(sort_node->getInput(0));
     return n_outputs(sort_node, prev_out.size());
   }
   const auto logical_values_node = dynamic_cast<const RelLogicalValues*>(ra_node);
   if (logical_values_node) {
     CHECK_EQ(size_t(0), logical_values_node->inputCount());
     return n_outputs(logical_values_node, logical_values_node->size());
   }
   const auto logical_union_node = dynamic_cast<const RelLogicalUnion*>(ra_node);
   if (logical_union_node) {
     return n_outputs(logical_union_node, logical_union_node->size());
   }
   LOG(FATAL) << "Unhandled ra_node type: " << ::toString(ra_node);
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::size_t hash_value ( RexAbstractInput const & rex_ab_input )

Definition at line 3525 of file RelAlgDag.cpp.

References Rex::hash_, and RexAbstractInput::in_index_.

Referenced by Executor::clearExternalCaches(), CodeGenerator::codegenColVar(), WindowFunctionContext::computeAggregateTreeCacheKey(), RelAlgExecutor::createWindowFunctionContext(), BoundingBoxIntersectJoinHashTable::generateCacheKey(), BaselineJoinHashTable::getAlternativeCacheKey(), PerfectJoinHashTable::getAlternativeCacheKey(), DataRecyclerUtil::getAlternativeTableKeys(), QueryPlanDagExtractor::handleTranslatedJoin(), PhysicalInput::hash(), CardinalityCacheKey::hash(), hash_value(), QueryRewriter::is_all_groupby_exprs_are_col_var(), AlterTableAlterColumnCommandRecoveryMgr::recoverAlterTableAlterColumnFromFile(), RangeJoinHashTable::reifyWithLayout(), BoundingBoxIntersectJoinHashTable::reifyWithLayout(), QueryRewriter::rewriteAggregateOnGroupByColumn(), RelAlgNode::setQueryPlanDag(), RexLiteral::toHash(), RexSubQuery::toHash(), and ScanNodeTableKeyCollector::visit().

                                                            {
   if (rex_ab_input.hash_) {
     return *rex_ab_input.hash_;
   }
   rex_ab_input.hash_ = typeid(RexAbstractInput).hash_code();
   boost::hash_combine(*rex_ab_input.hash_, rex_ab_input.in_index_);
   return *rex_ab_input.hash_;
 }

Here is the caller graph for this function:

std::size_t hash_value ( RexLiteral const & rex_literal )

Definition at line 3534 of file RelAlgDag.cpp.

References heavydb.dtypes::T.

                                                     {
   if (rex_literal.hash_) {
     return *rex_literal.hash_;
   }
   rex_literal.hash_ = typeid(RexLiteral).hash_code();
   boost::apply_visitor(
       [&rex_literal](auto&& current_val) {
         using T = std::decay_t<decltype(current_val)>;
         if constexpr (!std::is_same_v<boost::blank, T>) {
           static_assert(std::is_same_v<int64_t, T> || std::is_same_v<double, T> ||
                         std::is_same_v<std::string, T> || std::is_same_v<bool, T>);
           boost::hash_combine(*rex_literal.hash_, current_val);
         }
       },
       rex_literal.literal_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.type_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.target_type_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.scale_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.precision_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.target_scale_);
   boost::hash_combine(*rex_literal.hash_, rex_literal.target_precision_);
   return *rex_literal.hash_;
 }

std::size_t hash_value ( RexOperator const & rex_op )

Definition at line 3558 of file RelAlgDag.cpp.

References SQLTypeInfo::get_type_name(), RexOperator::getType(), Rex::hash_, RexOperator::op_, and RexOperator::operands_.

                                                 {
   if (rex_op.hash_) {
     return *rex_op.hash_;
   }
   rex_op.hash_ = typeid(RexOperator).hash_code();
   boost::hash_combine(*rex_op.hash_, rex_op.op_);
   boost::hash_combine(*rex_op.hash_, rex_op.operands_);
   boost::hash_combine(*rex_op.hash_, rex_op.getType().get_type_name());
   return *rex_op.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RexCase const & rex_case )

Definition at line 3569 of file RelAlgDag.cpp.

References RexCase::else_expr_, RexCase::expr_pair_list_, and Rex::hash_.

                                               {
   if (rex_case.hash_) {
     return *rex_case.hash_;
   }
   rex_case.hash_ = typeid(RexCase).hash_code();
   boost::hash_combine(*rex_case.hash_, rex_case.expr_pair_list_);
   boost::hash_combine(*rex_case.hash_, rex_case.else_expr_);
   return *rex_case.hash_;
 }

std::size_t hash_value ( RexFunctionOperator const & rex_op )

Definition at line 3579 of file RelAlgDag.cpp.

References SQLTypeInfo::get_type_name(), RexOperator::getType(), Rex::hash_, RexFunctionOperator::name_, RexOperator::op_, RexOperator::operands_, and toString().

                                                         {
   if (rex_op.hash_) {
     return *rex_op.hash_;
   }
   rex_op.hash_ = typeid(RexFunctionOperator).hash_code();
   boost::hash_combine(*rex_op.hash_, ::toString(rex_op.op_));
   boost::hash_combine(*rex_op.hash_, rex_op.getType().get_type_name());
   boost::hash_combine(*rex_op.hash_, rex_op.operands_);
   boost::hash_combine(*rex_op.hash_, rex_op.name_);
   return *rex_op.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( SortField const & sort_field )

Definition at line 3591 of file RelAlgDag.cpp.

References Ascending, SortField::field_, First, hash_value(), SortField::nulls_pos_, and SortField::sort_dir_.

                                                   {
   auto hash = boost::hash_value(sort_field.field_);
   boost::hash_combine(hash, sort_field.sort_dir_ == SortDirection::Ascending ? "a" : "d");
   boost::hash_combine(hash,
                       sort_field.nulls_pos_ == NullSortedPosition::First ? "f" : "l");
   return hash;
 }

Here is the call graph for this function:

std::size_t hash_value ( RexWindowFunctionOperator const & rex_window )

Definition at line 3599 of file RelAlgDag.cpp.

References RexWindowFunctionOperator::collation_, RexWindowFunctionOperator::frame_end_bound_, RexWindowFunctionOperator::frame_start_bound_, SQLTypeInfo::get_type_name(), RexFunctionOperator::getName(), RexOperator::getType(), Rex::hash_, hash_value(), RexWindowFunctionOperator::is_rows_, RexOperator::operands_, RexWindowFunctionOperator::order_keys_, and RexWindowFunctionOperator::partition_keys_.

                                                                   {
   if (rex_window.hash_) {
     return *rex_window.hash_;
   }
   rex_window.hash_ = typeid(RexWindowFunctionOperator).hash_code();
   boost::hash_combine(*rex_window.hash_, rex_window.getType().get_type_name());
   boost::hash_combine(*rex_window.hash_, rex_window.getName());
   boost::hash_combine(*rex_window.hash_, rex_window.is_rows_);
   boost::hash_combine(*rex_window.hash_, rex_window.collation_);
   boost::hash_combine(*rex_window.hash_, rex_window.operands_);
   boost::hash_combine(*rex_window.hash_, rex_window.partition_keys_);
   boost::hash_combine(*rex_window.hash_, rex_window.order_keys_);
   auto get_window_bound_hash =
       [](const RexWindowFunctionOperator::RexWindowBound& bound) {
         auto h = boost::hash_value(bound.bound_expr);
         boost::hash_combine(h, bound.unbounded);
         boost::hash_combine(h, bound.preceding);
         boost::hash_combine(h, bound.following);
         boost::hash_combine(h, bound.is_current_row);
         boost::hash_combine(h, bound.order_key);
         return h;
       };
   boost::hash_combine(*rex_window.hash_,
                       get_window_bound_hash(rex_window.frame_start_bound_));
   boost::hash_combine(*rex_window.hash_,
                       get_window_bound_hash(rex_window.frame_end_bound_));
   return *rex_window.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RexRef const & rex_ref )

Definition at line 3628 of file RelAlgDag.cpp.

References Rex::hash_, and RexRef::index_.

                                             {
   if (rex_ref.hash_) {
     return *rex_ref.hash_;
   }
   rex_ref.hash_ = typeid(RexRef).hash_code();
   boost::hash_combine(*rex_ref.hash_, rex_ref.index_);
   return *rex_ref.hash_;
 }

std::size_t hash_value ( RexAgg const & rex_agg )

Definition at line 3637 of file RelAlgDag.cpp.

References RexAgg::agg_, RexAgg::distinct_, SQLTypeInfo::get_type_name(), Rex::hash_, RexAgg::operands_, and RexAgg::type_.

                                             {
   if (rex_agg.hash_) {
     return *rex_agg.hash_;
   }
   rex_agg.hash_ = typeid(RexAgg).hash_code();
   boost::hash_combine(*rex_agg.hash_, rex_agg.operands_);
   boost::hash_combine(*rex_agg.hash_, rex_agg.agg_);
   boost::hash_combine(*rex_agg.hash_, rex_agg.distinct_);
   boost::hash_combine(*rex_agg.hash_, rex_agg.type_.get_type_name());
   return *rex_agg.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RexSubQuery const & rex_subq )

Definition at line 3649 of file RelAlgDag.cpp.

                                                   {
   if (rex_subq.hash_) {
     return *rex_subq.hash_;
   }
   rex_subq.hash_ = typeid(RexSubQuery).hash_code();
   boost::hash_combine(*rex_subq.hash_, rex_subq.ra_);
   return *rex_subq.hash_;
 }

std::size_t hash_value ( RexInput const & rex_input )

Definition at line 3658 of file RelAlgDag.cpp.

References RexAbstractInput::getIndex(), Rex::hash_, and RexInput::node_.

                                                 {
   if (rex_input.hash_) {
     return *rex_input.hash_;
   }
   rex_input.hash_ = typeid(RexInput).hash_code();
   boost::hash_combine(*rex_input.hash_, rex_input.node_);
   boost::hash_combine(*rex_input.hash_, rex_input.getIndex());
   return *rex_input.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RelScan const & rel_scan )

Definition at line 3668 of file RelAlgDag.cpp.

References RelScan::field_names_, RelAlgNode::hash_, TableDescriptor::tableId, TableDescriptor::tableName, RelScan::td_, and toString().

                                               {
   if (rel_scan.hash_) {
     return *rel_scan.hash_;
   }
   rel_scan.hash_ = typeid(RelScan).hash_code();
   boost::hash_combine(*rel_scan.hash_, rel_scan.td_->tableId);
   boost::hash_combine(*rel_scan.hash_, rel_scan.td_->tableName);
   boost::hash_combine(*rel_scan.hash_, ::toString(rel_scan.field_names_));
   return *rel_scan.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RelProject const & rel_project )

Definition at line 3679 of file RelAlgDag.cpp.

References RelProject::fields_, RelAlgNode::hash_, RelAlgNode::inputs_, and RelProject::scalar_exprs_.

                                                     {
   if (rel_project.hash_) {
     return *rel_project.hash_;
   }
   rel_project.hash_ = typeid(RelProject).hash_code();
   boost::hash_combine(*rel_project.hash_, rel_project.scalar_exprs_);
   boost::hash_combine(*rel_project.hash_, rel_project.fields_);
   boost::hash_combine(*rel_project.hash_, rel_project.inputs_);
   return *rel_project.hash_;
 }

std::size_t hash_value ( RelAggregate const & rel_agg )

Definition at line 3690 of file RelAlgDag.cpp.

References RelAggregate::agg_exprs_, RelAggregate::fields_, RelAggregate::groupby_count_, RelAlgNode::hash_, and RelAlgNode::inputs_.

                                                   {
   if (rel_agg.hash_) {
     return *rel_agg.hash_;
   }
   rel_agg.hash_ = typeid(RelAggregate).hash_code();
   boost::hash_combine(*rel_agg.hash_, rel_agg.groupby_count_);
   boost::hash_combine(*rel_agg.hash_, rel_agg.agg_exprs_);
   boost::hash_combine(*rel_agg.hash_, rel_agg.fields_);
   boost::hash_combine(*rel_agg.hash_, rel_agg.inputs_);
   return *rel_agg.hash_;
 }

std::size_t hash_value ( RelJoin const & rel_join )

Definition at line 3702 of file RelAlgDag.cpp.

References RelJoin::condition_, RelJoin::getJoinType(), RelAlgNode::hash_, RelAlgNode::inputs_, and toString().

                                               {
   if (rel_join.hash_) {
     return *rel_join.hash_;
   }
   rel_join.hash_ = typeid(RelJoin).hash_code();
   boost::hash_combine(*rel_join.hash_, rel_join.condition_);
   boost::hash_combine(*rel_join.hash_, rel_join.inputs_);
   boost::hash_combine(*rel_join.hash_, ::toString(rel_join.getJoinType()));
   return *rel_join.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RelTranslatedJoin const & rel_tr_join )

Definition at line 3713 of file RelAlgDag.cpp.

References RelTranslatedJoin::filter_ops_, RelAlgNode::hash_, RelTranslatedJoin::join_type_, RelTranslatedJoin::lhs_, RelTranslatedJoin::nested_loop_, RelTranslatedJoin::op_type_, RelTranslatedJoin::op_typeinfo_, RelTranslatedJoin::outer_join_cond_, RelTranslatedJoin::qualifier_, RelTranslatedJoin::rhs_, and toString().

                                                            {
   if (rel_tr_join.hash_) {
     return *rel_tr_join.hash_;
   }
   rel_tr_join.hash_ = typeid(RelTranslatedJoin).hash_code();
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.lhs_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.rhs_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.outer_join_cond_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.nested_loop_);
   boost::hash_combine(*rel_tr_join.hash_, ::toString(rel_tr_join.join_type_));
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.op_type_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.qualifier_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.op_typeinfo_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.filter_ops_);
   return *rel_tr_join.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RelFilter const & rel_filter )

Definition at line 3730 of file RelAlgDag.cpp.

References RelFilter::filter_, RelAlgNode::hash_, and RelAlgNode::inputs_.

                                                   {
   if (rel_filter.hash_) {
     return *rel_filter.hash_;
   }
   rel_filter.hash_ = typeid(RelFilter).hash_code();
   boost::hash_combine(*rel_filter.hash_, rel_filter.filter_);
   boost::hash_combine(*rel_filter.hash_, rel_filter.inputs_);
   return *rel_filter.hash_;
 }

std::size_t hash_value ( RelLeftDeepInnerJoin const & rel_join )

Definition at line 3740 of file RelAlgDag.cpp.

References RelLeftDeepInnerJoin::condition_, RelAlgNode::hash_, RelAlgNode::inputs_, RelLeftDeepInnerJoin::original_filter_, and RelLeftDeepInnerJoin::outer_conditions_per_level_.

                                                            {
   if (rel_join.hash_) {
     return *rel_join.hash_;
   }
   rel_join.hash_ = typeid(RelLeftDeepInnerJoin).hash_code();
   boost::hash_combine(*rel_join.hash_, rel_join.condition_);
   boost::hash_combine(*rel_join.hash_, rel_join.outer_conditions_per_level_);
   boost::hash_combine(*rel_join.hash_, rel_join.original_filter_);
   boost::hash_combine(*rel_join.hash_, rel_join.inputs_);
   return *rel_join.hash_;
 }

std::size_t hash_value ( RelCompound const & rel_compound )

Definition at line 3752 of file RelAlgDag.cpp.

References RelCompound::agg_exprs_, RelCompound::fields_, RelCompound::filter_expr_, RelCompound::groupby_count_, RelAlgNode::hash_, RelAlgNode::inputs_, RelCompound::is_agg_, RelCompound::scalar_sources_, and RelCompound::target_exprs_.

                                                       {
   if (rel_compound.hash_) {
     return *rel_compound.hash_;
   }
   rel_compound.hash_ = typeid(RelCompound).hash_code();
   boost::hash_combine(*rel_compound.hash_, rel_compound.filter_expr_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.is_agg_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.target_exprs_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.agg_exprs_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.scalar_sources_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.groupby_count_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.fields_);
   boost::hash_combine(*rel_compound.hash_, rel_compound.inputs_);
   return *rel_compound.hash_;
 }

std::size_t hash_value ( RelSort const & rel_sort )

Definition at line 3768 of file RelAlgDag.cpp.

References RelSort::collation_, RelAlgNode::hash_, RelAlgNode::inputs_, RelSort::limit_, and RelSort::offset_.

                                               {
   if (rel_sort.hash_) {
     return *rel_sort.hash_;
   }
   rel_sort.hash_ = typeid(RelSort).hash_code();
   boost::hash_combine(*rel_sort.hash_, rel_sort.collation_);
   boost::hash_combine(*rel_sort.hash_, rel_sort.limit_.has_value());
   boost::hash_combine(*rel_sort.hash_, rel_sort.limit_.value_or(0));
   boost::hash_combine(*rel_sort.hash_, rel_sort.offset_);
   boost::hash_combine(*rel_sort.hash_, rel_sort.inputs_);
   return *rel_sort.hash_;
 }

std::size_t hash_value ( RelModify const & rel_modify )

Definition at line 3781 of file RelAlgDag.cpp.

References RelModify::flattened_, RelAlgNode::hash_, RelAlgNode::inputs_, RelModify::operation_, RelModify::table_descriptor_, TableDescriptor::tableId, TableDescriptor::tableName, RelModify::target_column_list_, and RelModify::yieldModifyOperationString().

                                                   {
   if (rel_modify.hash_) {
     return *rel_modify.hash_;
   }
   rel_modify.hash_ = typeid(RelModify).hash_code();
   boost::hash_combine(*rel_modify.hash_, rel_modify.table_descriptor_->tableName);
   boost::hash_combine(*rel_modify.hash_, rel_modify.table_descriptor_->tableId);
   boost::hash_combine(*rel_modify.hash_, rel_modify.flattened_);
   boost::hash_combine(*rel_modify.hash_,
                       RelModify::yieldModifyOperationString(rel_modify.operation_));
   boost::hash_combine(*rel_modify.hash_, rel_modify.target_column_list_);
   boost::hash_combine(*rel_modify.hash_, rel_modify.inputs_);
   return *rel_modify.hash_;
 }

Here is the call graph for this function:

std::size_t hash_value ( RelTableFunction const & rel_tf )

Definition at line 3796 of file RelAlgDag.cpp.

References RelTableFunction::fields_, RelTableFunction::function_name_, RelAlgNode::hash_, RelAlgNode::inputs_, RelTableFunction::table_func_inputs_, and RelTableFunction::target_exprs_.

                                                      {
   if (rel_tf.hash_) {
     return *rel_tf.hash_;
   }
   rel_tf.hash_ = typeid(RelTableFunction).hash_code();
   boost::hash_combine(*rel_tf.hash_, rel_tf.function_name_);
   boost::hash_combine(*rel_tf.hash_, rel_tf.table_func_inputs_);
   boost::hash_combine(*rel_tf.hash_, rel_tf.target_exprs_);
   boost::hash_combine(*rel_tf.hash_, rel_tf.fields_);
   boost::hash_combine(*rel_tf.hash_, rel_tf.inputs_);
   return *rel_tf.hash_;
 }

std::size_t hash_value ( RelLogicalValues const & rel_lv )

Definition at line 3809 of file RelAlgDag.cpp.

References RelAlgNode::hash_, and RelLogicalValues::tuple_type_.

                                                      {
   if (rel_lv.hash_) {
     return *rel_lv.hash_;
   }
   rel_lv.hash_ = typeid(RelLogicalValues).hash_code();
   for (auto& target_meta_info : rel_lv.tuple_type_) {
     boost::hash_combine(*rel_lv.hash_, target_meta_info.get_resname());
     boost::hash_combine(*rel_lv.hash_, target_meta_info.get_type_info().get_type_name());
   }
   return *rel_lv.hash_;
 }

std::size_t hash_value ( RelLogicalUnion const & rel_lv )

Definition at line 3821 of file RelAlgDag.cpp.

References RelAlgNode::hash_, RelAlgNode::inputs_, and RelLogicalUnion::is_all_.

                                                     {
   if (rel_lv.hash_) {
     return *rel_lv.hash_;
   }
   rel_lv.hash_ = typeid(RelLogicalUnion).hash_code();
   boost::hash_combine(*rel_lv.hash_, rel_lv.is_all_);
   boost::hash_combine(*rel_lv.hash_, rel_lv.inputs_);
   return *rel_lv.hash_;
 }

std::string tree_string	(	const RelAlgNode *	ra,
		const size_t	depth
	)

Definition at line 3457 of file RelAlgDag.cpp.

References RelAlgNode::getInput(), RelAlgNode::inputCount(), run_benchmark_import::result, toString(), and tree_string().

Referenced by tree_string().

                                                                 {
   std::string result = std::string(2 * depth, ' ') + ::toString(ra) + '\n';
   for (size_t i = 0; i < ra->inputCount(); ++i) {
     result += tree_string(ra->getInput(i), depth + 1);
   }
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

bool g_cluster

bool g_enable_union

Definition at line 56 of file RelAlgExecutor.cpp.

Classes

Namespaces

Typedefs

Functions

Variables

Function Documentation

Variable Documentation