#include <PlanState.h>

Collaboration diagram for PlanState:

Public Types
using	DeletedColumnsMap = std::unordered_map< shared::TableKey, const ColumnDescriptor * >

using	HoistedFiltersSet = std::unordered_set< std::shared_ptr< Analyzer::Expr >>

Public Member Functions
	PlanState (const bool allow_lazy_fetch, const std::vector< InputTableInfo > &query_infos, const DeletedColumnsMap &deleted_columns, const Executor *executor)

	deleted_columns_ (deleted_columns)

	query_infos_ (query_infos)

	executor_ (executor)

void	allocateLocalColumnIds (const std::list< std::shared_ptr< const InputColDescriptor >> &global_col_ids)

int	getLocalColumnId (const Analyzer::ColumnVar *col_var, const bool fetch_column)

bool	isLazyFetchColumn (const Analyzer::Expr *target_expr) const

bool	isLazyFetchColumn (const InputColDescriptor &col_desc)

const ColumnDescriptor *	getDeletedColForTable (const shared::TableKey &table_key)

void	addSimpleQual (std::shared_ptr< Analyzer::Expr > simple_qual)

std::list< std::shared_ptr < Analyzer::Expr > >	getSimpleQuals () const

void	addNonHashtableQualForLeftJoin (size_t idx, std::shared_ptr< Analyzer::Expr > expr)

Public Attributes
std::vector< int64_t >	init_agg_vals_

std::vector< Analyzer::Expr * >	target_exprs_

HoistedFiltersSet	hoisted_filters_

std::unordered_map < InputColDescriptor, size_t >	global_to_local_col_ids_

std::set< shared::ColumnKey >	columns_to_fetch_

std::set< shared::ColumnKey >	columns_to_not_fetch_

std::unordered_map< size_t, std::vector< std::shared_ptr < Analyzer::Expr > > >	left_join_non_hashtable_quals_

bool	allow_lazy_fetch_

JoinInfo	join_info_

const DeletedColumnsMap	deleted_columns_

const std::vector < InputTableInfo > &	query_infos_

std::list< std::shared_ptr < Analyzer::Expr > >	simple_quals_

const Executor *	executor_

Detailed Description

Definition at line 42 of file PlanState.h.

Member Typedef Documentation

using PlanState::DeletedColumnsMap = std::unordered_map<shared::TableKey, const ColumnDescriptor*>

Definition at line 43 of file PlanState.h.

using PlanState::HoistedFiltersSet = std::unordered_set<std::shared_ptr<Analyzer::Expr>>

Definition at line 44 of file PlanState.h.

Constructor & Destructor Documentation

PlanState::PlanState	(	const bool	allow_lazy_fetch,
		const std::vector< InputTableInfo > &	query_infos,
		const DeletedColumnsMap &	deleted_columns,
		const Executor *	executor
	)

inline

Definition at line 46 of file PlanState.h.

50 : allow_lazy_fetch_(allow_lazy_fetch)

51 , join_info_({std::vector<std::shared_ptr<Analyzer::BinOper>>{}, {}})

PlanState::join_info_

JoinInfo join_info_

Definition: PlanState.h:65

PlanState::allow_lazy_fetch_

bool allow_lazy_fetch_

Definition: PlanState.h:64

Member Function Documentation

void PlanState::addNonHashtableQualForLeftJoin	(	size_t	idx,
		std::shared_ptr< Analyzer::Expr >	expr
	)

Definition at line 74 of file PlanState.cpp.

References left_join_non_hashtable_quals_.

                                                                                  {
   auto it = left_join_non_hashtable_quals_.find(idx);
   if (it == left_join_non_hashtable_quals_.end()) {
     std::vector<std::shared_ptr<Analyzer::Expr>> expr_vec{expr};
     left_join_non_hashtable_quals_.emplace(idx, std::move(expr_vec));
   } else {
     it->second.emplace_back(expr);
   }
 }

void PlanState::addSimpleQual ( std::shared_ptr< Analyzer::Expr > simple_qual )

inline

Definition at line 94 of file PlanState.h.

References simple_quals_.

                                                               {
     simple_quals_.push_back(simple_qual);
   }

void PlanState::allocateLocalColumnIds ( const std::list< std::shared_ptr< const InputColDescriptor >> & global_col_ids )

Definition at line 47 of file PlanState.cpp.

References CHECK, and global_to_local_col_ids_.

Referenced by ScalarCodeGenerator::prepare().

                                                                             {
   for (const auto& col_id : global_col_ids) {
     CHECK(col_id);
     const auto local_col_id = global_to_local_col_ids_.size();
     const auto it_ok =
         global_to_local_col_ids_.insert(std::make_pair(*col_id, local_col_id));
     // enforce uniqueness of the column ids in the scan plan
     CHECK(it_ok.second);
   }
 }

Here is the caller graph for this function:

PlanState::deleted_columns_ ( deleted_columns )

PlanState::executor_ ( executor )

inline

Definition at line 54 of file PlanState.h.

54 {}

const ColumnDescriptor* PlanState::getDeletedColForTable ( const shared::TableKey & table_key )

inline

Definition at line 86 of file PlanState.h.

References deleted_columns_.

                                                                                  {
     auto deleted_cols_it = deleted_columns_.find(table_key);
     if (deleted_cols_it != deleted_columns_.end()) {
       return deleted_cols_it->second;
     }
     return nullptr;
   }

int PlanState::getLocalColumnId	(	const Analyzer::ColumnVar *	col_var,
		const bool	fetch_column
	)

Definition at line 59 of file PlanState.cpp.

References CHECK, columns_to_fetch_, Analyzer::ColumnVar::get_rte_idx(), Analyzer::ColumnVar::getColumnKey(), and global_to_local_col_ids_.

Referenced by ScalarCodeGenerator::codegenColumn(), and CodeGenerator::colByteStream().

                                                          {
   CHECK(col_var);
   const auto& global_col_key = col_var->getColumnKey();
   const int scan_idx = col_var->get_rte_idx();
   InputColDescriptor scan_col_desc(
       global_col_key.column_id, global_col_key.table_id, global_col_key.db_id, scan_idx);
   const auto it = global_to_local_col_ids_.find(scan_col_desc);
   CHECK(it != global_to_local_col_ids_.end()) << "Expected to find " << scan_col_desc;
   if (fetch_column) {
     columns_to_fetch_.insert(global_col_key);
   }
   return it->second;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > PlanState::getSimpleQuals ( ) const

inline

Definition at line 98 of file PlanState.h.

References simple_quals_.

Referenced by CodeGenerator::codegen().

                                                               {
     return simple_quals_;
   }

Here is the caller graph for this function:

bool PlanState::isLazyFetchColumn ( const Analyzer::Expr * target_expr ) const

Definition at line 20 of file PlanState.cpp.

References allow_lazy_fetch_, columns_to_fetch_, columns_to_not_fetch_, get_column_descriptor(), and Analyzer::ColumnVar::getColumnKey().

Referenced by CodeGenerator::codegenColVar(), and isLazyFetchColumn().

                                                                        {
   if (!allow_lazy_fetch_) {
     return false;
   }
   const auto do_not_fetch_column = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
   if (!do_not_fetch_column || dynamic_cast<const Analyzer::Var*>(do_not_fetch_column)) {
     return false;
   }
   const auto& column_key = do_not_fetch_column->getColumnKey();
   if (column_key.table_id > 0) {
     const auto cd = get_column_descriptor(column_key);
     if (cd->isVirtualCol) {
       return false;
     }
   }
   std::set<shared::ColumnKey> intersect;
   std::set_intersection(columns_to_fetch_.begin(),
                         columns_to_fetch_.end(),
                         columns_to_not_fetch_.begin(),
                         columns_to_not_fetch_.end(),
                         std::inserter(intersect, intersect.begin()));
   if (!intersect.empty()) {
     throw CompilationRetryNoLazyFetch();
   }
   return columns_to_fetch_.find(column_key) == columns_to_fetch_.end();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool PlanState::isLazyFetchColumn ( const InputColDescriptor & col_desc )

inline

Definition at line 78 of file PlanState.h.

References InputColDescriptor::getColId(), InputDescriptor::getNestLevel(), InputColDescriptor::getScanDesc(), InputDescriptor::getTableKey(), and isLazyFetchColumn().

                                                              {
     Analyzer::ColumnVar column(
         SQLTypeInfo(),
         {col_desc.getScanDesc().getTableKey(), col_desc.getColId()},
         col_desc.getScanDesc().getNestLevel());
     return isLazyFetchColumn(&column);
   }