OmniSciDB  d2f719934e
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
RelAlgDagBuilder Class Reference

#include <RelAlgDagBuilder.h>

+ Inheritance diagram for RelAlgDagBuilder:
+ Collaboration diagram for RelAlgDagBuilder:

Public Member Functions

 RelAlgDagBuilder ()=delete
 
 RelAlgDagBuilder (const std::string &query_ra, const Catalog_Namespace::Catalog &cat, const RenderInfo *render_info)
 
 RelAlgDagBuilder (RelAlgDagBuilder &root_dag_builder, const rapidjson::Value &query_ast, const Catalog_Namespace::Catalog &cat, const RenderInfo *render_opts)
 
void eachNode (std::function< void(RelAlgNode const *)> const &) const
 
const RelAlgNodegetRootNode () const
 
std::shared_ptr< const RelAlgNodegetRootNodeShPtr () const
 
void registerSubquery (std::shared_ptr< RexSubQuery > subquery)
 
const std::vector
< std::shared_ptr< RexSubQuery > > & 
getSubqueries () const
 
void registerQueryHints (std::shared_ptr< RelAlgNode > node, Hints *hints_delivered, RegisteredQueryHint &global_query_hint)
 
std::optional
< RegisteredQueryHint
getQueryHint (const RelAlgNode *node) const
 
std::unordered_map< size_t,
std::unordered_map< unsigned,
RegisteredQueryHint > > & 
getQueryHints ()
 
const RegisteredQueryHintgetGlobalHints () const
 
void setGlobalQueryHints (const RegisteredQueryHint &global_hints)
 
void resetQueryExecutionState ()
 

Private Member Functions

void build (const rapidjson::Value &query_ast, RelAlgDagBuilder &root_dag_builder)
 

Private Attributes

const Catalog_Namespace::Catalogcat_
 
std::vector< std::shared_ptr
< RelAlgNode > > 
nodes_
 
std::vector< std::shared_ptr
< RexSubQuery > > 
subqueries_
 
const RenderInforender_info_
 
std::unordered_map< size_t,
std::unordered_map< unsigned,
RegisteredQueryHint > > 
query_hint_
 
RegisteredQueryHint global_hints_
 

Detailed Description

Builder class to create an in-memory, easy-to-navigate relational algebra DAG interpreted from a JSON representation from Calcite. Also, applies high level optimizations which can be expressed through relational algebra extended with RelCompound. The RelCompound node is an equivalent representation for sequences of RelFilter, RelProject and RelAggregate nodes. This coalescing minimizes the amount of intermediate buffers required to evaluate a query. Lower level optimizations are taken care by lower levels, mainly RelAlgTranslator and the IR code generation.

Definition at line 2112 of file RelAlgDagBuilder.h.

Constructor & Destructor Documentation

RelAlgDagBuilder::RelAlgDagBuilder ( )
delete
RelAlgDagBuilder::RelAlgDagBuilder ( const std::string &  query_ra,
const Catalog_Namespace::Catalog cat,
const RenderInfo render_info 
)

Constructs a RelAlg DAG from a JSON representation.

Parameters
query_raA JSON string representation of an RA tree from Calcite.
catDB catalog for the current user.
render_optsAdditional build options for render queries.

Definition at line 2723 of file RelAlgDagBuilder.cpp.

References build(), CHECK, logger::ERROR, LOG, RelAlgNode::resetRelAlgFirstId(), and VLOG.

2726  : cat_(cat), render_info_(render_info) {
2727  rapidjson::Document query_ast;
2728  query_ast.Parse(query_ra.c_str());
2729  VLOG(2) << "Parsing query RA JSON: " << query_ra;
2730  if (query_ast.HasParseError()) {
2731  query_ast.GetParseError();
2732  LOG(ERROR) << "Failed to parse RA tree from Calcite (offset "
2733  << query_ast.GetErrorOffset() << "):\n"
2734  << rapidjson::GetParseError_En(query_ast.GetParseError());
2735  VLOG(1) << "Failed to parse query RA: " << query_ra;
2736  throw std::runtime_error(
2737  "Failed to parse relational algebra tree. Possible query syntax error.");
2738  }
2739  CHECK(query_ast.IsObject());
2741  build(query_ast, *this);
2742 }
#define LOG(tag)
Definition: Logger.h:205
void build(const rapidjson::Value &query_ast, RelAlgDagBuilder &root_dag_builder)
const Catalog_Namespace::Catalog & cat_
const RenderInfo * render_info_
#define CHECK(condition)
Definition: Logger.h:211
#define VLOG(n)
Definition: Logger.h:305
static void resetRelAlgFirstId() noexcept

+ Here is the call graph for this function:

RelAlgDagBuilder::RelAlgDagBuilder ( RelAlgDagBuilder root_dag_builder,
const rapidjson::Value &  query_ast,
const Catalog_Namespace::Catalog cat,
const RenderInfo render_opts 
)

Constructs a sub-DAG for any subqueries. Should only be called during DAG building.

Parameters
root_dag_builderThe root DAG builder. The root stores pointers to all subqueries.
query_astThe current JSON node to build a DAG for.
catDB catalog for the current user.
render_optsAdditional build options for render queries.

Definition at line 2744 of file RelAlgDagBuilder.cpp.

References build().

2748  : cat_(cat), render_info_(render_info) {
2749  build(query_ast, root_dag_builder);
2750 }
void build(const rapidjson::Value &query_ast, RelAlgDagBuilder &root_dag_builder)
const Catalog_Namespace::Catalog & cat_
const RenderInfo * render_info_

+ Here is the call graph for this function:

Member Function Documentation

void RelAlgDagBuilder::build ( const rapidjson::Value &  query_ast,
RelAlgDagBuilder root_dag_builder 
)
private

Definition at line 2752 of file RelAlgDagBuilder.cpp.

References anonymous_namespace{RelAlgDagBuilder.cpp}::add_window_function_pre_project(), alterRAForRender(), anonymous_namespace{RelAlgDagBuilder.cpp}::bind_inputs(), cat_, CHECK, anonymous_namespace{RelAlgDagBuilder.cpp}::coalesce_nodes(), anonymous_namespace{RelLeftDeepInnerJoin.cpp}::create_left_deep_join(), eliminate_dead_columns(), eliminate_dead_subqueries(), eliminate_identical_copy(), field(), fold_filters(), g_cluster, get_left_deep_join_root(), anonymous_namespace{RelAlgDagBuilder.cpp}::handleQueryHint(), hoist_filter_cond_to_cross_join(), anonymous_namespace{RelAlgDagBuilder.cpp}::mark_nops(), nodes_, query_hint_, render_info_, details::RelAlgDispatcher::run(), anonymous_namespace{RelAlgDagBuilder.cpp}::separate_window_function_expressions(), simplify_sort(), sink_projected_boolean_expr_to_join(), and subqueries_.

Referenced by RelAlgDagBuilder().

2753  {
2754  const auto& rels = field(query_ast, "rels");
2755  CHECK(rels.IsArray());
2756  try {
2757  nodes_ = details::RelAlgDispatcher(cat_).run(rels, lead_dag_builder);
2758  } catch (const QueryNotSupported&) {
2759  throw;
2760  }
2761  CHECK(!nodes_.empty());
2763 
2764  if (render_info_) {
2765  // Alter the RA for render. Do this before any flattening/optimizations are done to
2766  // the tree.
2768  }
2769 
2770  handleQueryHint(nodes_, this);
2771  mark_nops(nodes_);
2776  std::vector<const RelAlgNode*> filtered_left_deep_joins;
2777  std::vector<const RelAlgNode*> left_deep_joins;
2778  for (const auto& node : nodes_) {
2779  const auto left_deep_join_root = get_left_deep_join_root(node);
2780  // The filter which starts a left-deep join pattern must not be coalesced
2781  // since it contains (part of) the join condition.
2782  if (left_deep_join_root) {
2783  left_deep_joins.push_back(left_deep_join_root.get());
2784  if (std::dynamic_pointer_cast<const RelFilter>(left_deep_join_root)) {
2785  filtered_left_deep_joins.push_back(left_deep_join_root.get());
2786  }
2787  }
2788  }
2789  if (filtered_left_deep_joins.empty()) {
2791  }
2792  eliminate_dead_columns(nodes_);
2793  eliminate_dead_subqueries(subqueries_, nodes_.back().get());
2796  nodes_,
2797  g_cluster /* always_add_project_if_first_project_is_window_expr */,
2798  query_hint_);
2799  coalesce_nodes(nodes_, left_deep_joins, query_hint_);
2800  CHECK(nodes_.back().use_count() == 1);
2801  create_left_deep_join(nodes_);
2802 }
void handleQueryHint(const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDagBuilder *dag_builder) noexcept
void coalesce_nodes(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< const RelAlgNode * > &left_deep_joins, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void bind_inputs(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void hoist_filter_cond_to_cross_join(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::shared_ptr< const RelAlgNode > get_left_deep_join_root(const std::shared_ptr< RelAlgNode > &node)
void sink_projected_boolean_expr_to_join(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void eliminate_identical_copy(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::pair< std::shared_ptr< RelLeftDeepInnerJoin >, std::shared_ptr< const RelAlgNode > > create_left_deep_join(const std::shared_ptr< RelAlgNode > &left_deep_join_root)
const Catalog_Namespace::Catalog & cat_
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
void simplify_sort(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
std::vector< std::shared_ptr< RexSubQuery > > subqueries_
const RenderInfo * render_info_
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31
std::vector< std::shared_ptr< RelAlgNode > > nodes_
void mark_nops(const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void separate_window_function_expressions(std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
#define CHECK(condition)
Definition: Logger.h:211
bool g_cluster
void alterRAForRender(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const RenderInfo &render_info)
std::vector< std::shared_ptr< RelAlgNode > > run(const rapidjson::Value &rels, RelAlgDagBuilder &root_dag_builder)
void add_window_function_pre_project(std::vector< std::shared_ptr< RelAlgNode >> &nodes, const bool always_add_project_if_first_project_is_window_expr, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void fold_filters(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void eliminate_dead_subqueries(std::vector< std::shared_ptr< RexSubQuery >> &subqueries, RelAlgNode const *root)
void eliminate_dead_columns(std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void RelAlgDagBuilder::eachNode ( std::function< void(RelAlgNode const *)> const callback) const

Definition at line 2804 of file RelAlgDagBuilder.cpp.

References nodes_.

2805  {
2806  for (auto const& node : nodes_) {
2807  if (node) {
2808  callback(node.get());
2809  }
2810  }
2811 }
std::vector< std::shared_ptr< RelAlgNode > > nodes_
const RegisteredQueryHint& RelAlgDagBuilder::getGlobalHints ( ) const
inline

Definition at line 2359 of file RelAlgDagBuilder.h.

References global_hints_.

2359 { return global_hints_; }
RegisteredQueryHint global_hints_
std::optional<RegisteredQueryHint> RelAlgDagBuilder::getQueryHint ( const RelAlgNode node) const
inline

Definition at line 2331 of file RelAlgDagBuilder.h.

References RelAlgNode::getId(), global_hints_, RegisteredQueryHint::isAnyQueryHintDelivered(), query_hint_, and RelAlgNode::toHash().

2331  {
2332  auto node_it = query_hint_.find(node->toHash());
2333  if (node_it != query_hint_.end()) {
2334  auto const& registered_query_hint_map = node_it->second;
2335  auto hint_it = registered_query_hint_map.find(node->getId());
2336  if (hint_it != registered_query_hint_map.end()) {
2337  auto const& registered_query_hint = hint_it->second;
2339  // apply global hint to the registered query hint for this query block
2340  return std::make_optional(registered_query_hint || global_hints_);
2341  } else {
2342  return std::make_optional(registered_query_hint);
2343  }
2344  }
2345  }
2347  // if no hint is registered from this query block
2348  // we return global hint instead
2349  return std::make_optional(global_hints_);
2350  }
2351  return std::nullopt;
2352  }
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
unsigned getId() const
RegisteredQueryHint global_hints_
virtual size_t toHash() const =0
bool isAnyQueryHintDelivered() const
Definition: QueryHint.h:231

+ Here is the call graph for this function:

std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint> >& RelAlgDagBuilder::getQueryHints ( )
inline

Definition at line 2355 of file RelAlgDagBuilder.h.

References query_hint_.

2355  {
2356  return query_hint_;
2357  }
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
const RelAlgNode& RelAlgDagBuilder::getRootNode ( ) const
inline

Returns the root node of the DAG.

Definition at line 2145 of file RelAlgDagBuilder.h.

References CHECK, and nodes_.

2145  {
2146  CHECK(nodes_.size());
2147  const auto& last_ptr = nodes_.back();
2148  CHECK(last_ptr);
2149  return *last_ptr;
2150  }
std::vector< std::shared_ptr< RelAlgNode > > nodes_
#define CHECK(condition)
Definition: Logger.h:211
std::shared_ptr<const RelAlgNode> RelAlgDagBuilder::getRootNodeShPtr ( ) const
inline

Definition at line 2152 of file RelAlgDagBuilder.h.

References CHECK, and nodes_.

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::parse_subquery().

2152  {
2153  CHECK(nodes_.size());
2154  return nodes_.back();
2155  }
std::vector< std::shared_ptr< RelAlgNode > > nodes_
#define CHECK(condition)
Definition: Logger.h:211

+ Here is the caller graph for this function:

const std::vector<std::shared_ptr<RexSubQuery> >& RelAlgDagBuilder::getSubqueries ( ) const
inline

Gets all registered subqueries. Only the root DAG can contain subqueries.

Definition at line 2168 of file RelAlgDagBuilder.h.

References subqueries_.

2168  {
2169  return subqueries_;
2170  }
std::vector< std::shared_ptr< RexSubQuery > > subqueries_
void RelAlgDagBuilder::registerQueryHints ( std::shared_ptr< RelAlgNode node,
Hints hints_delivered,
RegisteredQueryHint global_query_hint 
)
inline

Definition at line 2172 of file RelAlgDagBuilder.h.

References CHECK, RegisteredQueryHint::columnar_output, RegisteredQueryHint::cpu_mode, g_enable_columnar_output, kColumnarOutput, kCpuMode, kOverlapsAllowGpuBuild, kOverlapsBucketThreshold, kOverlapsKeysPerBin, kOverlapsMaxSize, kOverlapsNoCache, kRowwiseOutput, RegisteredQueryHint::overlaps_allow_gpu_build, RegisteredQueryHint::overlaps_bucket_threshold, RegisteredQueryHint::overlaps_keys_per_bin, RegisteredQueryHint::overlaps_max_size, RegisteredQueryHint::overlaps_no_cache, query_hint_, RegisteredQueryHint::registerHint(), RegisteredQueryHint::rowwise_output, and VLOG.

2174  {
2175  std::optional<bool> has_global_columnar_output_hint = std::nullopt;
2176  std::optional<bool> has_global_rowwise_output_hint = std::nullopt;
2177  RegisteredQueryHint query_hint;
2178  for (auto it = hints_delivered->begin(); it != hints_delivered->end(); it++) {
2179  auto target = it->second;
2180  auto hint_type = it->first;
2181  switch (hint_type) {
2182  case QueryHint::kCpuMode: {
2183  query_hint.registerHint(QueryHint::kCpuMode);
2184  query_hint.cpu_mode = true;
2185  if (target.isGlobalHint()) {
2186  global_query_hint.registerHint(QueryHint::kCpuMode);
2187  global_query_hint.cpu_mode = true;
2188  }
2189  break;
2190  }
2192  has_global_columnar_output_hint = target.isGlobalHint();
2193  break;
2194  }
2196  has_global_rowwise_output_hint = target.isGlobalHint();
2197  break;
2198  }
2200  CHECK(target.getListOptions().size() == 1);
2201  double overlaps_bucket_threshold = std::stod(target.getListOptions()[0]);
2202  if (overlaps_bucket_threshold >= 0.0 && overlaps_bucket_threshold <= 90.0) {
2204  query_hint.overlaps_bucket_threshold = overlaps_bucket_threshold;
2205  if (target.isGlobalHint()) {
2207  global_query_hint.overlaps_bucket_threshold = overlaps_bucket_threshold;
2208  }
2209  } else {
2210  VLOG(1) << "Skip the given query hint \"overlaps_bucket_threshold\" ("
2211  << overlaps_bucket_threshold
2212  << ") : the hint value should be within 0.0 ~ 90.0";
2213  }
2214  break;
2215  }
2217  CHECK(target.getListOptions().size() == 1);
2218  std::stringstream ss(target.getListOptions()[0]);
2219  int overlaps_max_size;
2220  ss >> overlaps_max_size;
2221  if (overlaps_max_size >= 0) {
2223  query_hint.overlaps_max_size = (size_t)overlaps_max_size;
2224  if (target.isGlobalHint()) {
2225  global_query_hint.registerHint(QueryHint::kOverlapsMaxSize);
2226  global_query_hint.overlaps_max_size = (size_t)overlaps_max_size;
2227  }
2228  } else {
2229  VLOG(1) << "Skip the query hint \"overlaps_max_size\" (" << overlaps_max_size
2230  << ") : the hint value should be larger than or equal to zero";
2231  }
2232  break;
2233  }
2236  query_hint.overlaps_allow_gpu_build = true;
2237  if (target.isGlobalHint()) {
2239  global_query_hint.overlaps_allow_gpu_build = true;
2240  }
2241  break;
2242  }
2245  query_hint.overlaps_no_cache = true;
2246  if (target.isGlobalHint()) {
2247  global_query_hint.registerHint(QueryHint::kOverlapsNoCache);
2248  global_query_hint.overlaps_no_cache = true;
2249  }
2250  VLOG(1) << "Skip auto tuner and hashtable caching for overlaps join.";
2251  break;
2252  }
2254  CHECK(target.getListOptions().size() == 1);
2255  double overlaps_keys_per_bin = std::stod(target.getListOptions()[0]);
2256  if (overlaps_keys_per_bin > 0.0 &&
2257  overlaps_keys_per_bin < std::numeric_limits<double>::max()) {
2259  query_hint.overlaps_keys_per_bin = overlaps_keys_per_bin;
2260  if (target.isGlobalHint()) {
2261  global_query_hint.registerHint(QueryHint::kOverlapsKeysPerBin);
2262  global_query_hint.overlaps_keys_per_bin = overlaps_keys_per_bin;
2263  }
2264  } else {
2265  VLOG(1) << "Skip the given query hint \"overlaps_keys_per_bin\" ("
2266  << overlaps_keys_per_bin
2267  << ") : the hint value should be larger than zero";
2268  }
2269  break;
2270  }
2271  default:
2272  break;
2273  }
2274  }
2275  // we have four cases depending on 1) g_enable_columnar_output flag
2276  // and 2) query hint status: columnar_output and rowwise_output
2277  // case 1. g_enable_columnar_output = true
2278  // case 1.a) columnar_output = true (so rowwise_output = false);
2279  // case 1.b) rowwise_output = true (so columnar_output = false);
2280  // case 2. g_enable_columnar_output = false
2281  // case 2.a) columnar_output = true (so rowwise_output = false);
2282  // case 2.b) rowwise_output = true (so columnar_output = false);
2283  // case 1.a --> use columnar output
2284  // case 1.b --> use rowwise output
2285  // case 2.a --> use columnar output
2286  // case 2.b --> use rowwise output
2287  if (has_global_columnar_output_hint.has_value() &&
2288  has_global_rowwise_output_hint.has_value()) {
2289  VLOG(1)
2290  << "Two hints 1) columnar output and 2) rowwise output are enabled together, "
2291  << "so skip them and use the runtime configuration "
2292  "\"g_enable_columnar_output\"";
2293  } else if (has_global_columnar_output_hint.has_value() &&
2294  !has_global_rowwise_output_hint.has_value()) {
2296  VLOG(1) << "We already enable columnar output by default "
2297  "(g_enable_columnar_output = true), so skip this columnar output hint";
2298  } else {
2300  query_hint.columnar_output = true;
2301  if (*has_global_columnar_output_hint) {
2302  global_query_hint.registerHint(QueryHint::kColumnarOutput);
2303  global_query_hint.columnar_output = true;
2304  }
2305  }
2306  } else if (!has_global_columnar_output_hint.has_value() &&
2307  has_global_rowwise_output_hint.has_value()) {
2308  if (!g_enable_columnar_output) {
2309  VLOG(1) << "We already use the default rowwise output (g_enable_columnar_output "
2310  "= false), so skip this rowwise output hint";
2311  } else {
2313  query_hint.rowwise_output = true;
2314  if (*has_global_rowwise_output_hint) {
2315  global_query_hint.registerHint(QueryHint::kRowwiseOutput);
2316  global_query_hint.rowwise_output = true;
2317  }
2318  }
2319  }
2320  auto node_key = node->toHash();
2321  auto it = query_hint_.find(node_key);
2322  if (it == query_hint_.end()) {
2323  std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
2324  hint_map.emplace(node->getId(), query_hint);
2325  query_hint_.emplace(node_key, hint_map);
2326  } else {
2327  it->second.emplace(node->getId(), query_hint);
2328  }
2329  }
bool overlaps_allow_gpu_build
Definition: QueryHint.h:216
double overlaps_keys_per_bin
Definition: QueryHint.h:218
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > query_hint_
bool g_enable_columnar_output
Definition: Execute.cpp:95
void registerHint(const QueryHint hint)
Definition: QueryHint.h:236
size_t overlaps_max_size
Definition: QueryHint.h:215
#define CHECK(condition)
Definition: Logger.h:211
double overlaps_bucket_threshold
Definition: QueryHint.h:214
#define VLOG(n)
Definition: Logger.h:305

+ Here is the call graph for this function:

void RelAlgDagBuilder::registerSubquery ( std::shared_ptr< RexSubQuery subquery)
inline

Registers a subquery with a root DAG builder. Should only be called during DAG building and registration should only occur on the root.

Definition at line 2161 of file RelAlgDagBuilder.h.

References subqueries_.

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::parse_subquery().

2161  {
2162  subqueries_.push_back(subquery);
2163  }
std::vector< std::shared_ptr< RexSubQuery > > subqueries_

+ Here is the caller graph for this function:

void RelAlgDagBuilder::resetQueryExecutionState ( )

Gets all registered subqueries. Only the root DAG can contain subqueries.

Definition at line 2813 of file RelAlgDagBuilder.cpp.

References nodes_.

2813  {
2814  for (auto& node : nodes_) {
2815  if (node) {
2816  node->resetQueryExecutionState();
2817  }
2818  }
2819 }
std::vector< std::shared_ptr< RelAlgNode > > nodes_
void RelAlgDagBuilder::setGlobalQueryHints ( const RegisteredQueryHint global_hints)
inline

Definition at line 2361 of file RelAlgDagBuilder.h.

References global_hints_.

2361  {
2362  global_hints_ = global_hints;
2363  }
RegisteredQueryHint global_hints_

Member Data Documentation

const Catalog_Namespace::Catalog& RelAlgDagBuilder::cat_
private

Definition at line 2373 of file RelAlgDagBuilder.h.

Referenced by build().

RegisteredQueryHint RelAlgDagBuilder::global_hints_
private

Definition at line 2382 of file RelAlgDagBuilder.h.

Referenced by getGlobalHints(), getQueryHint(), and setGlobalQueryHints().

std::vector<std::shared_ptr<RelAlgNode> > RelAlgDagBuilder::nodes_
private
std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint> > RelAlgDagBuilder::query_hint_
private

Definition at line 2381 of file RelAlgDagBuilder.h.

Referenced by build(), getQueryHint(), getQueryHints(), and registerQueryHints().

const RenderInfo* RelAlgDagBuilder::render_info_
private

Definition at line 2376 of file RelAlgDagBuilder.h.

Referenced by build().

std::vector<std::shared_ptr<RexSubQuery> > RelAlgDagBuilder::subqueries_
private

Definition at line 2375 of file RelAlgDagBuilder.h.

Referenced by build(), getSubqueries(), and registerSubquery().


The documentation for this class was generated from the following files: