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

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 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

static auto const HASH_N = boost::hash_value("n")
 

Typedef Documentation

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

Notes:

Definition at line 43 of file RelAlgDag.h.

using RANodeOutput = std::vector<RexInput>

Definition at line 2638 of file RelAlgDag.h.

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

Definition at line 289 of file RelAlgDag.h.

using RexLiteralArray = std::vector<RexLiteral>

Definition at line 230 of file RelAlgDag.h.

using TupleContentsArray = std::vector<RexLiteralArray>

Definition at line 231 of file RelAlgDag.h.

Enumeration Type Documentation

enum NullSortedPosition
strong
Enumerator
First 
Last 

Definition at line 482 of file RelAlgDag.h.

enum SortDirection
strong
Enumerator
Ascending 
Descending 

Definition at line 480 of file RelAlgDag.h.

Function Documentation

RANodeOutput get_node_output ( const RelAlgNode ra_node)

Definition at line 370 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().

370  {
371  const auto scan_node = dynamic_cast<const RelScan*>(ra_node);
372  if (scan_node) {
373  // Scan node has no inputs, output contains all columns in the table.
374  CHECK_EQ(size_t(0), scan_node->inputCount());
375  return n_outputs(scan_node, scan_node->size());
376  }
377  const auto project_node = dynamic_cast<const RelProject*>(ra_node);
378  if (project_node) {
379  // Project output count doesn't depend on the input
380  CHECK_EQ(size_t(1), project_node->inputCount());
381  return n_outputs(project_node, project_node->size());
382  }
383  const auto filter_node = dynamic_cast<const RelFilter*>(ra_node);
384  if (filter_node) {
385  // Filter preserves shape
386  CHECK_EQ(size_t(1), filter_node->inputCount());
387  const auto prev_out = get_node_output(filter_node->getInput(0));
388  return n_outputs(filter_node, prev_out.size());
389  }
390  const auto aggregate_node = dynamic_cast<const RelAggregate*>(ra_node);
391  if (aggregate_node) {
392  // Aggregate output count doesn't depend on the input
393  CHECK_EQ(size_t(1), aggregate_node->inputCount());
394  return n_outputs(aggregate_node, aggregate_node->size());
395  }
396  const auto compound_node = dynamic_cast<const RelCompound*>(ra_node);
397  if (compound_node) {
398  // Compound output count doesn't depend on the input
399  CHECK_EQ(size_t(1), compound_node->inputCount());
400  return n_outputs(compound_node, compound_node->size());
401  }
402  const auto join_node = dynamic_cast<const RelJoin*>(ra_node);
403  if (join_node) {
404  // Join concatenates the outputs from the inputs and the output
405  // directly references the nodes in the input.
406  CHECK_EQ(size_t(2), join_node->inputCount());
407  auto lhs_out =
408  n_outputs(join_node->getInput(0), get_node_output(join_node->getInput(0)).size());
409  const auto rhs_out =
410  n_outputs(join_node->getInput(1), get_node_output(join_node->getInput(1)).size());
411  lhs_out.insert(lhs_out.end(), rhs_out.begin(), rhs_out.end());
412  return lhs_out;
413  }
414  const auto table_func_node = dynamic_cast<const RelTableFunction*>(ra_node);
415  if (table_func_node) {
416  // Table Function output count doesn't depend on the input
417  return n_outputs(table_func_node, table_func_node->size());
418  }
419  const auto sort_node = dynamic_cast<const RelSort*>(ra_node);
420  if (sort_node) {
421  // Sort preserves shape
422  CHECK_EQ(size_t(1), sort_node->inputCount());
423  const auto prev_out = get_node_output(sort_node->getInput(0));
424  return n_outputs(sort_node, prev_out.size());
425  }
426  const auto logical_values_node = dynamic_cast<const RelLogicalValues*>(ra_node);
427  if (logical_values_node) {
428  CHECK_EQ(size_t(0), logical_values_node->inputCount());
429  return n_outputs(logical_values_node, logical_values_node->size());
430  }
431  const auto logical_union_node = dynamic_cast<const RelLogicalUnion*>(ra_node);
432  if (logical_union_node) {
433  return n_outputs(logical_union_node, logical_union_node->size());
434  }
435  LOG(FATAL) << "Unhandled ra_node type: " << ::toString(ra_node);
436  return {};
437 }
#define CHECK_EQ(x, y)
Definition: Logger.h:230
#define LOG(tag)
Definition: Logger.h:216
std::string toString(const Executor::ExtModuleKinds &kind)
Definition: Execute.h:1448
std::vector< RexInput > n_outputs(const RelAlgNode *node, const size_t n)
Definition: RelAlgDag.cpp:95
RANodeOutput get_node_output(const RelAlgNode *ra_node)
Definition: RelAlgDag.cpp:370

+ 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 3217 of file RelAlgDag.cpp.

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

Referenced by tree_string().

3217  {
3218  std::string result = std::string(2 * depth, ' ') + ::toString(ra) + '\n';
3219  for (size_t i = 0; i < ra->inputCount(); ++i) {
3220  result += tree_string(ra->getInput(i), depth + 1);
3221  }
3222  return result;
3223 }
std::string toString(const Executor::ExtModuleKinds &kind)
Definition: Execute.h:1448
std::string tree_string(const RelAlgNode *ra, const size_t depth)
Definition: RelAlgDag.cpp:3217

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Variable Documentation