RelAlgDagBuilder.h File Reference

#include <iterator>
#include <memory>
#include <unordered_map>
#include <rapidjson/document.h>
#include <boost/core/noncopyable.hpp>
#include "Catalog/Catalog.h"
#include "Shared/ConfigResolve.h"
#include "Shared/sql_window_function_to_string.h"
#include "QueryEngine/Rendering/RenderInfo.h"
#include "QueryEngine/TargetMetaInfo.h"
#include "QueryEngine/TypePunning.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	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	QueryNotSupported
class	RelAlgDagBuilder

Namespaces
	std

Typedefs
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
std::string	tree_string (const RelAlgNode *, const size_t indent=0)
RANodeOutput	get_node_output (const RelAlgNode *ra_node)

Typedef Documentation

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

Definition at line 34 of file RelAlgDagBuilder.h.

using RANodeOutput = std::vector<RexInput>

Definition at line 1564 of file RelAlgDagBuilder.h.

using RexLiteralArray = std::vector<RexLiteral>

Definition at line 207 of file RelAlgDagBuilder.h.

using TupleContentsArray = std::vector<RexLiteralArray>

Definition at line 208 of file RelAlgDagBuilder.h.

Enumeration Type Documentation

enum NullSortedPosition

strong

Enumerator
First
Last

Definition at line 421 of file RelAlgDagBuilder.h.

{ First, Last };

enum SortDirection

strong

Enumerator
Ascending
Descending

Definition at line 419 of file RelAlgDagBuilder.h.

{ Ascending, Descending };

Function Documentation

RANodeOutput get_node_output

(

const RelAlgNode *

ra_node

)

Definition at line 112 of file RelAlgDagBuilder.cpp.

References CHECK(), CHECK_EQ, get_node_output(), and anonymous_namespace{RelAlgDagBuilder.cpp}::n_outputs().

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().

                                                        {
  RANodeOutput outputs;
  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
    CHECK_EQ(size_t(1), table_func_node->inputCount());
    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());
  }
  CHECK(false);
  return outputs;
}

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	indent = 0
	)

Definition at line 2200 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(indent, ' ') + ra->toString() + "\n";
  for (size_t i = 0; i < ra->inputCount(); ++i) {
    result += tree_string(ra->getInput(i), indent + 2);
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function: