#include <QueryPlanDagCache.h>

Collaboration diagram for QueryPlanDagCache:

Public Member Functions
	QueryPlanDagCache (size_t max_node_cache_size=MAX_NODE_CACHE_SIZE)

	QueryPlanDagCache (QueryPlanDagCache &&other)=delete

QueryPlanDagCache &	operator= (QueryPlanDagCache &&other)=delete

	QueryPlanDagCache (const QueryPlanDagCache &)=delete

QueryPlanDagCache &	operator= (const QueryPlanDagCache &)=delete

std::optional< RelNodeId >	addNodeIfAbsent (const RelAlgNode *)

void	connectNodes (const RelNodeId parent_id, const RelNodeId child_id)

std::vector< const Analyzer::ColumnVar * >	collectColVars (const Analyzer::Expr *target)

size_t	getCurrentNodeMapSize () const

void	setNodeMapMaxSize (const size_t map_size)

size_t	getJoinColumnsInfoHash (const Analyzer::Expr *join_expr, JoinColumnSide target_side, bool extract_only_col_id)

size_t	translateColVarsToInfoHash (std::vector< const Analyzer::ColumnVar * > &col_vars, bool col_id_only) const

void	clearQueryPlanCache ()

void	printDag ()

Private Member Functions
size_t	getCurrentNodeMapSizeUnlocked () const

size_t	getCurrentNodeMapCardinality () const

Private Attributes
RelNodeMap	node_map_

QueryPlanDag	cached_query_plan_dag_

size_t	max_node_map_size_

std::mutex	cache_lock_

ColumnVarsVisitor	col_var_visitor_

Detailed Description

Definition at line 110 of file QueryPlanDagCache.h.

Constructor & Destructor Documentation

QueryPlanDagCache::QueryPlanDagCache ( size_t max_node_cache_size = MAX_NODE_CACHE_SIZE )

inline

Definition at line 112 of file QueryPlanDagCache.h.

113 : max_node_map_size_(max_node_cache_size) {}

QueryPlanDagCache::max_node_map_size_

size_t max_node_map_size_

Definition: QueryPlanDagCache.h:151

QueryPlanDagCache::QueryPlanDagCache ( QueryPlanDagCache && other )

delete

QueryPlanDagCache::QueryPlanDagCache ( const QueryPlanDagCache & )

delete

Member Function Documentation

std::optional< RelNodeId > QueryPlanDagCache::addNodeIfAbsent ( const RelAlgNode * node )

Definition at line 25 of file QueryPlanDagCache.cpp.

References cache_lock_, cached_query_plan_dag_, getCurrentNodeMapCardinality(), getCurrentNodeMapSizeUnlocked(), max_node_map_size_, node_map_, run_benchmark_import::result, and RelAlgNode::toHash().

Referenced by QueryPlanDagExtractor::extractQueryPlanDagImpl(), QueryPlanDagExtractor::handleTranslatedJoin(), and QueryPlanDagExtractor::register_and_visit().

                                                                                 {
   std::lock_guard<std::mutex> cache_lock(cache_lock_);
   auto key = node->toHash();
   auto const result = node_map_.emplace(key, getCurrentNodeMapCardinality());
   if (result.second) {
     if (getCurrentNodeMapSizeUnlocked() > max_node_map_size_ ||
         getCurrentNodeMapCardinality() == SIZE_MAX) {
       // unfortunately our DAG cache becomes full
       // so clear the internal status and skip the query plan DAG extraction
       node_map_.clear();
       cached_query_plan_dag_.graph().clear();
       return std::nullopt;
     }
   }
   return result.first->second;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void QueryPlanDagCache::clearQueryPlanCache ( )

Definition at line 146 of file QueryPlanDagCache.cpp.

References cache_lock_, cached_query_plan_dag_, and node_map_.

                                             {
   std::lock_guard<std::mutex> cache_lock(cache_lock_);
   node_map_.clear();
   cached_query_plan_dag_.graph().clear();
 }

std::vector< const Analyzer::ColumnVar * > QueryPlanDagCache::collectColVars ( const Analyzer::Expr * target )

Definition at line 152 of file QueryPlanDagCache.cpp.

References col_var_visitor_, and ScalarExprVisitor< T >::visit().

Referenced by QueryPlanDagExtractor::getColVar(), and getJoinColumnsInfoHash().

                                 {
   if (target) {
     return col_var_visitor_.visit(target);
   }
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void QueryPlanDagCache::connectNodes	(	const RelNodeId	parent_id,
		const RelNodeId	child_id
	)

Definition at line 42 of file QueryPlanDagCache.cpp.

References cache_lock_, and cached_query_plan_dag_.

Referenced by QueryPlanDagExtractor::registerNodeToDagCache().

                                                                {
   std::lock_guard<std::mutex> cache_lock(cache_lock_);
   boost::add_vertex(parent_id, cached_query_plan_dag_);
   boost::add_vertex(child_id, cached_query_plan_dag_);
   add_edge_by_label(parent_id, child_id, cached_query_plan_dag_);
 }

Here is the caller graph for this function:

size_t QueryPlanDagCache::getCurrentNodeMapCardinality ( ) const

private

Definition at line 142 of file QueryPlanDagCache.cpp.

References node_map_.

Referenced by addNodeIfAbsent().

                                                              {
   return node_map_.size();
 }

Here is the caller graph for this function:

size_t QueryPlanDagCache::getCurrentNodeMapSize ( ) const

Definition at line 133 of file QueryPlanDagCache.cpp.

References cache_lock_, and getCurrentNodeMapSizeUnlocked().

                                                       {
   std::lock_guard<std::mutex> cache_lock(cache_lock_);
   return getCurrentNodeMapSizeUnlocked();
 }

Here is the call graph for this function:

size_t QueryPlanDagCache::getCurrentNodeMapSizeUnlocked ( ) const

private

Definition at line 138 of file QueryPlanDagCache.cpp.

References elem_size_, and node_map_.

Referenced by addNodeIfAbsent(), and getCurrentNodeMapSize().

                                                               {
   return node_map_.size() * elem_size_;
 }

Here is the caller graph for this function:

size_t QueryPlanDagCache::getJoinColumnsInfoHash	(	const Analyzer::Expr *	join_expr,
		JoinColumnSide	target_side,
		bool	extract_only_col_id
	)

Definition at line 78 of file QueryPlanDagCache.cpp.

References CHECK, collectColVars(), EMPTY_HASHED_PLAN_DAG_KEY, kDirect, kInner, kOuter, kQual, and translateColVarsToInfoHash().

                                                                            {
   // this function returns qual_bin_oper's info depending on the requested context
   // such as extracted col_id of inner join cols
   // (target_side = JoinColumnSide::kInner, extract_only_col_id = true)
   // and extract all infos of an entire join quals
   // (target_side = JoinColumnSide::kQual, extract_only_col_id = false)
   // todo (yoonmin): we may need to use a whole "EXPR" contents in a future
   // to support a join qual with more general expression like A.a + 1 = (B.b * 2) / 2
   if (!join_expr) {
     return EMPTY_HASHED_PLAN_DAG_KEY;
   }
   auto get_sorted_col_info = [=](const Analyzer::Expr* join_cols) -> size_t {
     auto join_col_vars = collectColVars(join_cols);
     CHECK(!join_col_vars.empty())
         << "Join expression should have at least one join column variable";
     return translateColVarsToInfoHash(join_col_vars, extract_only_col_id);
   };
   auto hashed_join_col_info = EMPTY_HASHED_PLAN_DAG_KEY;
   if (target_side == JoinColumnSide::kQual) {
     auto qual_bin_oper = dynamic_cast<const Analyzer::BinOper*>(join_expr);
     CHECK(qual_bin_oper);
     boost::hash_combine(hashed_join_col_info,
                         get_sorted_col_info(qual_bin_oper->get_left_operand()));
     boost::hash_combine(hashed_join_col_info,
                         get_sorted_col_info(qual_bin_oper->get_right_operand()));
   } else if (target_side == JoinColumnSide::kInner) {
     auto qual_bin_oper = dynamic_cast<const Analyzer::BinOper*>(join_expr);
     CHECK(qual_bin_oper);
     boost::hash_combine(hashed_join_col_info,
                         get_sorted_col_info(qual_bin_oper->get_left_operand()));
   } else if (target_side == JoinColumnSide::kOuter) {
     auto qual_bin_oper = dynamic_cast<const Analyzer::BinOper*>(join_expr);
     CHECK(qual_bin_oper);
     boost::hash_combine(hashed_join_col_info,
                         get_sorted_col_info(qual_bin_oper->get_right_operand()));
   } else {
     CHECK(target_side == JoinColumnSide::kDirect);
     boost::hash_combine(hashed_join_col_info, get_sorted_col_info(join_expr));
   }
   return hashed_join_col_info;
 }

Here is the call graph for this function:

QueryPlanDagCache& QueryPlanDagCache::operator= ( QueryPlanDagCache && other )

delete

QueryPlanDagCache& QueryPlanDagCache::operator= ( const QueryPlanDagCache & )

delete

void QueryPlanDagCache::printDag ( )

Definition at line 122 of file QueryPlanDagCache.cpp.

References cached_query_plan_dag_, and node_map_.

                                  {
   std::cout << "Edge list:" << std::endl;
   boost::print_graph(cached_query_plan_dag_.graph());
   std::ostringstream os;
   os << "\n\nNodeMap:\n";
   for (auto& kv : node_map_) {
     os << "[" << kv.second << "] " << kv.first << "\n";
   }
   std::cout << os.str() << std::endl;
 }

void QueryPlanDagCache::setNodeMapMaxSize ( const size_t map_size )

Definition at line 50 of file QueryPlanDagCache.cpp.

References cache_lock_, and max_node_map_size_.

                                                                {
   std::lock_guard<std::mutex> cache_lock(cache_lock_);
   max_node_map_size_ = map_size;
 }

size_t QueryPlanDagCache::translateColVarsToInfoHash	(	std::vector< const Analyzer::ColumnVar * > &	col_vars,
		bool	col_id_only
	)		const

Definition at line 55 of file QueryPlanDagCache.cpp.

References EMPTY_HASHED_PLAN_DAG_KEY, Analyzer::ColumnVar::getColumnKey(), and gpu_enabled::sort().

Referenced by getJoinColumnsInfoHash(), and QueryPlanDagExtractor::handleTranslatedJoin().

                             {
   // we need to sort col ids to prevent missing data reuse case in multi column qual
   // scenarios like a) A.a = B.b and A.c = B.c and b) A.c = B.c and A.a = B.a
   std::sort(col_vars.begin(),
             col_vars.end(),
             [](const Analyzer::ColumnVar* lhs, const Analyzer::ColumnVar* rhs) {
               return lhs->getColumnKey() < rhs->getColumnKey();
             });
   size_t col_vars_info_hash = EMPTY_HASHED_PLAN_DAG_KEY;
   using Hasher = std::function<void(Analyzer::ColumnVar const*)>;
   Hasher hash_col_id = [&col_vars_info_hash](auto const* cv) {
     boost::hash_combine(col_vars_info_hash, cv->getColumnKey().column_id);
   };
   Hasher hash_cv_string = [&col_vars_info_hash](auto const* cv) {
     boost::hash_combine(col_vars_info_hash, cv->toString());
   };
   std::for_each(
       col_vars.begin(), col_vars.end(), col_id_only ? hash_col_id : hash_cv_string);
   return col_vars_info_hash;
 }