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/sql_window_function_to_string.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

ColumnNameList

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.

Hints

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

Definition at line 692 of file RelAlgDagBuilder.h.

RANodeOutput

using RANodeOutput = std::vector<RexInput>

Definition at line 1898 of file RelAlgDagBuilder.h.

RelAlgInputs

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

Definition at line 259 of file RelAlgDagBuilder.h.

RexLiteralArray

using RexLiteralArray = std::vector<RexLiteral>

Definition at line 213 of file RelAlgDagBuilder.h.

TupleContentsArray

using TupleContentsArray = std::vector<RexLiteralArray>

Definition at line 214 of file RelAlgDagBuilder.h.

Enumeration Type Documentation

NullSortedPosition

enum NullSortedPosition

strong

Enumerator
First
Last

Definition at line 431 of file RelAlgDagBuilder.h.

{ First, Last };

SortDirection

enum SortDirection

strong

Enumerator
Ascending
Descending

Definition at line 429 of file RelAlgDagBuilder.h.

{ Ascending, Descending };

Function Documentation

get_node_output()

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(), RelAlgNode::size(), 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:

tree_string()

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: