RelAlgDag.h File Reference

#include <atomic>
#include <iterator>
#include <memory>
#include <optional>
#include <unordered_map>
#include <rapidjson/document.h>
#include <boost/core/noncopyable.hpp>
#include <boost/functional/hash.hpp>
#include "Catalog/Catalog.h"
#include "QueryEngine/QueryHint.h"
#include "QueryEngine/Rendering/RenderInfo.h"
#include "QueryEngine/TargetMetaInfo.h"
#include "QueryEngine/TypePunning.h"
#include "Shared/toString.h"
#include "Utils/FsiUtils.h"

Include dependency graph for RelAlgDag.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	RelRexToStringConfig
class	RelAlgDagNode
class	RelAlgDagNode::Visitor
class	Rex
class	RexScalar
class	RexAbstractInput
class	RexLiteral
class	RexOperator
class	RexCase
class	RexFunctionOperator
class	SortField
class	RexWindowFunctionOperator
struct	RexWindowFunctionOperator::RexWindowBound
class	RexRef
class	RexAgg
class	RelAlgNode
class	RexSubQuery
class	RexInput
struct	std::hash< RexInput >
class	RelScan
class	ModifyManipulationTarget
class	RelProject
class	RelAggregate
class	RelJoin
class	RelTranslatedJoin
class	RelFilter
class	RelLeftDeepInnerJoin
class	RelCompound
class	RelSort
class	RelModify
class	RelTableFunction
class	RelLogicalValues
class	RelLogicalUnion
class	QueryNotSupported
class	RelAlgDag
struct	RelAlgDagModifier
struct	RelAlgDagBuilder

Namespaces
	std
	boost

Macros
#define	HEAVYAI_SPECIALIZE_HASH_VALUE_OF_POINTER(T)

Typedefs
using	RelAlgInputs = std::vector< std::shared_ptr< const RelAlgNode >>
using	ColumnNameList = std::vector< std::string >
using	RexLiteralArray = std::vector< RexLiteral >
using	TupleContentsArray = std::vector< RexLiteralArray >
using	RANodeOutput = std::vector< RexInput >

Enumerations
enum	SortDirection { SortDirection::Ascending, SortDirection::Descending }
enum	NullSortedPosition { NullSortedPosition::First, NullSortedPosition::Last }

Functions
RANodeOutput	get_node_output (const RelAlgNode *ra_node)
std::string	tree_string (const RelAlgNode *, const size_t depth=0)

Variables
constexpr size_t	boost::HASH_NULLPTR {0u}

Macro Definition Documentation

#define HEAVYAI_SPECIALIZE_HASH_VALUE_OF_POINTER

(

T

)

Value:

template <>                                          \
  inline std::size_t hash_value(T const* const& ptr) { \
    return ptr ? ptr->toHash() : HASH_NULLPTR;         \
  }                                                    \
  template <>                                          \
  inline std::size_t hash_value(T* const& ptr) {       \
    return ptr ? ptr->toHash() : HASH_NULLPTR;         \
  }

Definition at line 3442 of file RelAlgDag.h.

Typedef Documentation

using ColumnNameList = std::vector<std::string>

Definition at line 72 of file RelAlgDag.h.

using RANodeOutput = std::vector<RexInput>

Definition at line 3432 of file RelAlgDag.h.

using RelAlgInputs = std::vector<std::shared_ptr<const RelAlgNode>>

Definition at line 71 of file RelAlgDag.h.

using RexLiteralArray = std::vector<RexLiteral>

Definition at line 333 of file RelAlgDag.h.

using TupleContentsArray = std::vector<RexLiteralArray>

Definition at line 334 of file RelAlgDag.h.

Enumeration Type Documentation

enum NullSortedPosition

strong

Enumerator
First
Last

Definition at line 533 of file RelAlgDag.h.

{ First, Last };

enum SortDirection

strong

Enumerator
Ascending
Descending

Definition at line 531 of file RelAlgDag.h.

{ Ascending, Descending };

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::string tree_string	(	const RelAlgNode *	,
		const size_t	depth = 0
	)

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: