RelAlgDagBuilder.h File Reference

#include <atomic>
#include <iterator>
#include <memory>
#include <unordered_map>
#include <rapidjson/document.h>
#include <boost/core/noncopyable.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 RelAlgDagBuilder.h:

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

Go to the source code of this file.

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

Namespaces
	std

Typedefs
using	ColumnNameList = std::vector< std::string >
using	RexLiteralArray = std::vector< RexLiteral >
using	TupleContentsArray = std::vector< RexLiteralArray >
using	RelAlgInputs = std::vector< std::shared_ptr< const RelAlgNode >>
using	Hints = std::unordered_map< std::string, HintExplained >
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)

Typedef Documentation

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

Notes:

• All copy constuctors of child classes of RelAlgNode are deep copies, and are invoked by the the RelAlgNode::deepCopy() overloads.

Definition at line 40 of file RelAlgDagBuilder.h.

using Hints = std::unordered_map<std::string, HintExplained>

Definition at line 692 of file RelAlgDagBuilder.h.

using RANodeOutput = std::vector<RexInput>

Definition at line 1853 of file RelAlgDagBuilder.h.

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

Definition at line 268 of file RelAlgDagBuilder.h.

using RexLiteralArray = std::vector<RexLiteral>

Definition at line 219 of file RelAlgDagBuilder.h.

using TupleContentsArray = std::vector<RexLiteralArray>

Definition at line 220 of file RelAlgDagBuilder.h.

Enumeration Type Documentation

enum NullSortedPosition

strong

Enumerator
First
Last

Definition at line 427 of file RelAlgDagBuilder.h.

{ First, Last };

enum SortDirection

strong

Enumerator
Ascending
Descending

Definition at line 425 of file RelAlgDagBuilder.h.

{ Ascending, Descending };

Function Documentation

RANodeOutput get_node_output

(

const RelAlgNode *

ra_node

)

Definition at line 152 of file RelAlgDagBuilder.cpp.

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

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::bind_inputs(), anonymous_namespace{RelAlgDagBuilder.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: " << ra_node->toString();
  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 2674 of file RelAlgDagBuilder.cpp.

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

Referenced by tree_string().

                                                                {
  std::string result = std::string(2 * depth, ' ') + ra->toString() + '\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: