OmniSciDB  340b00dbf6
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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:

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.

enum SortDirection
strong
Enumerator
Ascending 
Descending 

Definition at line 425 of file RelAlgDagBuilder.h.

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

152  {
153  const auto scan_node = dynamic_cast<const RelScan*>(ra_node);
154  if (scan_node) {
155  // Scan node has no inputs, output contains all columns in the table.
156  CHECK_EQ(size_t(0), scan_node->inputCount());
157  return n_outputs(scan_node, scan_node->size());
158  }
159  const auto project_node = dynamic_cast<const RelProject*>(ra_node);
160  if (project_node) {
161  // Project output count doesn't depend on the input
162  CHECK_EQ(size_t(1), project_node->inputCount());
163  return n_outputs(project_node, project_node->size());
164  }
165  const auto filter_node = dynamic_cast<const RelFilter*>(ra_node);
166  if (filter_node) {
167  // Filter preserves shape
168  CHECK_EQ(size_t(1), filter_node->inputCount());
169  const auto prev_out = get_node_output(filter_node->getInput(0));
170  return n_outputs(filter_node, prev_out.size());
171  }
172  const auto aggregate_node = dynamic_cast<const RelAggregate*>(ra_node);
173  if (aggregate_node) {
174  // Aggregate output count doesn't depend on the input
175  CHECK_EQ(size_t(1), aggregate_node->inputCount());
176  return n_outputs(aggregate_node, aggregate_node->size());
177  }
178  const auto compound_node = dynamic_cast<const RelCompound*>(ra_node);
179  if (compound_node) {
180  // Compound output count doesn't depend on the input
181  CHECK_EQ(size_t(1), compound_node->inputCount());
182  return n_outputs(compound_node, compound_node->size());
183  }
184  const auto join_node = dynamic_cast<const RelJoin*>(ra_node);
185  if (join_node) {
186  // Join concatenates the outputs from the inputs and the output
187  // directly references the nodes in the input.
188  CHECK_EQ(size_t(2), join_node->inputCount());
189  auto lhs_out =
190  n_outputs(join_node->getInput(0), get_node_output(join_node->getInput(0)).size());
191  const auto rhs_out =
192  n_outputs(join_node->getInput(1), get_node_output(join_node->getInput(1)).size());
193  lhs_out.insert(lhs_out.end(), rhs_out.begin(), rhs_out.end());
194  return lhs_out;
195  }
196  const auto table_func_node = dynamic_cast<const RelTableFunction*>(ra_node);
197  if (table_func_node) {
198  // Table Function output count doesn't depend on the input
199  return n_outputs(table_func_node, table_func_node->size());
200  }
201  const auto sort_node = dynamic_cast<const RelSort*>(ra_node);
202  if (sort_node) {
203  // Sort preserves shape
204  CHECK_EQ(size_t(1), sort_node->inputCount());
205  const auto prev_out = get_node_output(sort_node->getInput(0));
206  return n_outputs(sort_node, prev_out.size());
207  }
208  const auto logical_values_node = dynamic_cast<const RelLogicalValues*>(ra_node);
209  if (logical_values_node) {
210  CHECK_EQ(size_t(0), logical_values_node->inputCount());
211  return n_outputs(logical_values_node, logical_values_node->size());
212  }
213  const auto logical_union_node = dynamic_cast<const RelLogicalUnion*>(ra_node);
214  if (logical_union_node) {
215  return n_outputs(logical_union_node, logical_union_node->size());
216  }
217  LOG(FATAL) << "Unhandled ra_node type: " << ra_node->toString();
218  return {};
219 }
#define CHECK_EQ(x, y)
Definition: Logger.h:205
#define LOG(tag)
Definition: Logger.h:188
virtual std::string toString() const =0
RANodeOutput get_node_output(const RelAlgNode *ra_node)
std::vector< RexInput > n_outputs(const RelAlgNode *node, const size_t n)

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

2674  {
2675  std::string result = std::string(2 * depth, ' ') + ra->toString() + '\n';
2676  for (size_t i = 0; i < ra->inputCount(); ++i) {
2677  result += tree_string(ra->getInput(i), depth + 1);
2678  }
2679  return result;
2680 }
std::string tree_string(const RelAlgNode *ra, const size_t depth)

+ Here is the call graph for this function:

+ Here is the caller graph for this function: