#include <PlanState.h>

Collaboration diagram for PlanState:

Public Types
using	TableId = int

using	ColumnId = int

Public Member Functions
	PlanState (const bool allow_lazy_fetch, const Executor *executor)

	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)

bool	isLazyFetchColumn (const InputColDescriptor &col_desc)

Public Attributes
std::vector< int64_t >	init_agg_vals_

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

std::unordered_map < InputColDescriptor, size_t >	global_to_local_col_ids_

std::set< std::pair< TableId, ColumnId > >	columns_to_fetch_

std::set< std::pair< TableId, ColumnId > >	columns_to_not_fetch_

bool	allow_lazy_fetch_

JoinInfo	join_info_

const Executor *	executor_

Detailed Description

Definition at line 41 of file PlanState.h.

Member Typedef Documentation

using PlanState::ColumnId = int

Definition at line 48 of file PlanState.h.

using PlanState::TableId = int

Definition at line 47 of file PlanState.h.

Constructor & Destructor Documentation

PlanState::PlanState	(	const bool	allow_lazy_fetch,
		const Executor *	executor
	)

inline

Definition at line 42 of file PlanState.h.

43 : allow_lazy_fetch_(allow_lazy_fetch)

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

PlanState::join_info_

JoinInfo join_info_

Definition: PlanState.h:56

PlanState::allow_lazy_fetch_

bool allow_lazy_fetch_

Definition: PlanState.h:55

Member Function Documentation

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

Definition at line 50 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 call graph for this function:

Here is the caller graph for this function:

PlanState::executor_ ( executor )

inline

Definition at line 45 of file PlanState.h.

45 {}

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

Definition at line 62 of file PlanState.cpp.

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

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

                                                          {
   CHECK(col_var);
   const int table_id = col_var->get_table_id();
   int global_col_id = col_var->get_column_id();
   const int scan_idx = col_var->get_rte_idx();
   InputColDescriptor scan_col_desc(global_col_id, table_id, scan_idx);
   const auto it = global_to_local_col_ids_.find(scan_col_desc);
   CHECK(it != global_to_local_col_ids_.end());
   if (fetch_column) {
     columns_to_fetch_.insert(std::make_pair(table_id, global_col_id));
   }
   return it->second;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 20 of file PlanState.cpp.

References allow_lazy_fetch_, columns_to_fetch_, columns_to_not_fetch_, executor_, and get_column_descriptor().

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;
   }
   if (do_not_fetch_column->get_table_id() > 0) {
     auto cd = get_column_descriptor(do_not_fetch_column->get_column_id(),
                                     do_not_fetch_column->get_table_id(),
                                     *executor_->getCatalog());
     if (cd->isVirtualCol) {
       return false;
     }
   }
   std::set<std::pair<int, int>> 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(std::make_pair(do_not_fetch_column->get_table_id(),
                                                do_not_fetch_column->get_column_id())) ==
          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 66 of file PlanState.h.

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

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