RelAlgExecutionUnit.h File Reference

Execution unit for relational algebra. It's a low-level description of any relational algebra operation in a format understood by our VM. More...

#include "Descriptors/InputDescriptors.h"
#include "QueryHint.h"
#include "RelAlgDag.h"
#include "Shared/DbObjectKeys.h"
#include "Shared/sqldefs.h"
#include "Shared/toString.h"
#include "TableFunctions/TableFunctionOutputBufferSizeType.h"
#include "TableFunctions/TableFunctionsFactory.h"
#include "ThriftHandler/QueryState.h"
#include <boost/graph/adjacency_list.hpp>
#include <list>
#include <memory>
#include <optional>
#include <vector>

Include dependency graph for RelAlgExecutionUnit.h:

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

Go to the source code of this file.

Classes
struct	HashTableBuildDag
struct	SortInfo
struct	JoinCondition
struct	RelAlgExecutionUnit
struct	TableFunctionExecutionUnit

Namespaces
	Analyzer

Typedefs
using	AdjacentList = boost::adjacency_list< boost::setS, boost::vecS, boost::directedS >
using	RelNodeId = size_t
using	RelNodeExplainedHash = size_t
using	QueryPlanDAG = std::string
using	QueryPlanHash = size_t
using	HashTableBuildDagMap = std::unordered_map< size_t, HashTableBuildDag >
using	TableIdToNodeMap = std::unordered_map< shared::TableKey, const RelAlgNode * >
using	JoinQualsPerNestingLevel = std::vector< JoinCondition >
using	ResultSetPtr = std::shared_ptr< ResultSet >

Enumerations
enum	JoinColumnSide { kInner, kOuter, kQual, kDirect }
enum	SortAlgorithm { SortAlgorithm::Default, SortAlgorithm::SpeculativeTopN, SortAlgorithm::StreamingTopN }

Functions
std::ostream &	operator<< (std::ostream &os, const RelAlgExecutionUnit &ra_exe_unit)
std::string	ra_exec_unit_desc_for_caching (const RelAlgExecutionUnit &ra_exe_unit)

Variables
constexpr char const *	EMPTY_QUERY_PLAN = ""
constexpr QueryPlanHash	EMPTY_HASHED_PLAN_DAG_KEY = 0

Detailed Description

Execution unit for relational algebra. It's a low-level description of any relational algebra operation in a format understood by our VM.

Definition in file RelAlgExecutionUnit.h.

Typedef Documentation

using AdjacentList = boost::adjacency_list<boost::setS, boost::vecS, boost::directedS>

Definition at line 43 of file RelAlgExecutionUnit.h.

using HashTableBuildDagMap = std::unordered_map<size_t, HashTableBuildDag>

Definition at line 86 of file RelAlgExecutionUnit.h.

using JoinQualsPerNestingLevel = std::vector<JoinCondition>

Definition at line 129 of file RelAlgExecutionUnit.h.

using QueryPlanDAG = std::string

Definition at line 56 of file RelAlgExecutionUnit.h.

using QueryPlanHash = size_t

Definition at line 58 of file RelAlgExecutionUnit.h.

using RelNodeExplainedHash = size_t

Definition at line 51 of file RelAlgExecutionUnit.h.

using RelNodeId = size_t

Definition at line 49 of file RelAlgExecutionUnit.h.

using ResultSetPtr = std::shared_ptr<ResultSet>

Definition at line 183 of file RelAlgExecutionUnit.h.

using TableIdToNodeMap = std::unordered_map<shared::TableKey, const RelAlgNode*>

Definition at line 94 of file RelAlgExecutionUnit.h.

Enumeration Type Documentation

enum JoinColumnSide

Enumerator
kInner
kOuter
kQual
kDirect

Definition at line 96 of file RelAlgExecutionUnit.h.

                    {
  kInner,
  kOuter,
  kQual,   // INNER + OUTER
  kDirect  // set target directly (i.e., put Analyzer::Expr* instead of
           // Analyzer::BinOper*)
};

enum SortAlgorithm

strong

Enumerator
Default
SpeculativeTopN
StreamingTopN

Definition at line 106 of file RelAlgExecutionUnit.h.

{ Default, SpeculativeTopN, StreamingTopN };

Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

Definition at line 1667 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, anonymous_namespace{Execute.cpp}::expr_container_to_string(), RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::input_col_descs, join(), RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::query_plan_dag_hash, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::simple_quals, anonymous_namespace{Execute.cpp}::sort_algorithm_to_string(), RelAlgExecutionUnit::sort_info, RelAlgExecutionUnit::target_exprs, to_string(), toString(), RelAlgExecutionUnit::union_all, and RelAlgExecutionUnit::use_bump_allocator.

                                                                               {
  os << "\n\tExtracted Query Plan Dag Hash: " << ra_exe_unit.query_plan_dag_hash;
  os << "\n\tTable/Col/Levels: ";
  for (const auto& input_col_desc : ra_exe_unit.input_col_descs) {
    const auto& scan_desc = input_col_desc->getScanDesc();
    os << "(" << scan_desc.getTableKey() << ", " << input_col_desc->getColId() << ", "
       << scan_desc.getNestLevel() << ") ";
  }
  if (!ra_exe_unit.simple_quals.empty()) {
    os << "\n\tSimple Quals: "
       << boost::algorithm::join(expr_container_to_string(ra_exe_unit.simple_quals),
                                 ", ");
  }
  if (!ra_exe_unit.quals.empty()) {
    os << "\n\tQuals: "
       << boost::algorithm::join(expr_container_to_string(ra_exe_unit.quals), ", ");
  }
  if (!ra_exe_unit.join_quals.empty()) {
    os << "\n\tJoin Quals: ";
    for (size_t i = 0; i < ra_exe_unit.join_quals.size(); i++) {
      const auto& join_condition = ra_exe_unit.join_quals[i];
      os << "\t\t" << std::to_string(i) << " " << ::toString(join_condition.type);
      os << boost::algorithm::join(expr_container_to_string(join_condition.quals), ", ");
    }
  }
  if (!ra_exe_unit.groupby_exprs.empty()) {
    os << "\n\tGroup By: "
       << boost::algorithm::join(expr_container_to_string(ra_exe_unit.groupby_exprs),
                                 ", ");
  }
  os << "\n\tProjected targets: "
     << boost::algorithm::join(expr_container_to_string(ra_exe_unit.target_exprs), ", ");
  os << "\n\tHas Estimator: " << ::toString(ra_exe_unit.estimator == nullptr);
  os << "\n\tSort Info: ";
  const auto& sort_info = ra_exe_unit.sort_info;
  os << "\n\t  Order Entries: "
     << boost::algorithm::join(expr_container_to_string(sort_info.order_entries), ", ");
  os << "\n\t  Algorithm: " << sort_algorithm_to_string(sort_info.algorithm);
  os << "\n\t  Limit: " << std::to_string(sort_info.limit);
  os << "\n\t  Offset: " << std::to_string(sort_info.offset);
  os << "\n\tScan Limit: " << std::to_string(ra_exe_unit.scan_limit);
  os << "\n\tBump Allocator: " << ::toString(ra_exe_unit.use_bump_allocator);
  if (ra_exe_unit.union_all) {
    os << "\n\tUnion: " << std::string(*ra_exe_unit.union_all ? "UNION ALL" : "UNION");
  }
  return os;
}

Here is the call graph for this function:

std::string ra_exec_unit_desc_for_caching

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 1616 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::input_col_descs, RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::simple_quals, RelAlgExecutionUnit::target_exprs, to_string(), and toString().

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                                {
  // todo(yoonmin): replace a cache key as a DAG representation of a query plan
  // instead of ra_exec_unit description if possible
  std::ostringstream os;
  for (const auto& input_col_desc : ra_exe_unit.input_col_descs) {
    const auto& scan_desc = input_col_desc->getScanDesc();
    os << scan_desc.getTableKey() << "," << input_col_desc->getColId() << ","
       << scan_desc.getNestLevel();
  }
  if (!ra_exe_unit.simple_quals.empty()) {
    for (const auto& qual : ra_exe_unit.simple_quals) {
      if (qual) {
        os << qual->toString() << ",";
      }
    }
  }
  if (!ra_exe_unit.quals.empty()) {
    for (const auto& qual : ra_exe_unit.quals) {
      if (qual) {
        os << qual->toString() << ",";
      }
    }
  }
  if (!ra_exe_unit.join_quals.empty()) {
    for (size_t i = 0; i < ra_exe_unit.join_quals.size(); i++) {
      const auto& join_condition = ra_exe_unit.join_quals[i];
      os << std::to_string(i) << ::toString(join_condition.type);
      for (const auto& qual : join_condition.quals) {
        if (qual) {
          os << qual->toString() << ",";
        }
      }
    }
  }
  if (!ra_exe_unit.groupby_exprs.empty()) {
    for (const auto& qual : ra_exe_unit.groupby_exprs) {
      if (qual) {
        os << qual->toString() << ",";
      }
    }
  }
  for (const auto& expr : ra_exe_unit.target_exprs) {
    if (expr) {
      os << expr->toString() << ",";
    }
  }
  os << ::toString(ra_exe_unit.estimator == nullptr);
  os << std::to_string(ra_exe_unit.scan_limit);
  return os.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

constexpr QueryPlanHash EMPTY_HASHED_PLAN_DAG_KEY = 0

Definition at line 104 of file RelAlgExecutionUnit.h.

Referenced by RelAlgExecutor::createUnionWorkUnit(), QueryPlanDagExtractor::extractJoinInfo(), HashtableRecycler::getCachedHashtableWithoutCacheKey(), ResultSetRecycler::getCachedResultSetWithoutCacheKey(), HashtableRecycler::getHashtableAccessPathInfo(), ChunkMetadataRecycler::getItemFromCache(), HashtableRecycler::getJoinColumnInfoHash(), QueryPlanDagCache::getJoinColumnsInfoHash(), ResultSetRecycler::getOutputMetaInfo(), QueryPlanDagExtractor::handleTranslatedJoin(), anonymous_namespace{RelAlgExecutor.cpp}::has_valid_query_plan_dag(), HashingSchemeRecycler::hasItemInCache(), OverlapsTuningParamRecycler::hasItemInCache(), ChunkMetadataRecycler::hasItemInCache(), ResultSetRecycler::hasItemInCache(), HashtableRecycler::hasItemInCache(), HashtableRecycler::isInvalidHashTableCacheKey(), HashingSchemeRecycler::putItemToCache(), OverlapsTuningParamRecycler::putItemToCache(), ChunkMetadataRecycler::putItemToCache(), ResultSetRecycler::putItemToCache(), HashtableRecycler::putItemToCache(), ResultSetRecycler::removeItemFromCache(), HashtableRecycler::removeItemFromCache(), and QueryPlanDagCache::translateColVarsToInfoHash().

constexpr char const* EMPTY_QUERY_PLAN = ""

Definition at line 103 of file RelAlgExecutionUnit.h.

Referenced by QueryPlanDagExtractor::extractQueryPlanDag(), QueryPlanDagExtractor::getExtractedQueryPlanDagStr(), and RaExecutionSequence::next().