#include <PlanState.h>

Collaboration diagram for PlanState:

Public Types
using	TableId = int

using	ColumnId = int

using	DeletedColumnsMap = std::unordered_map< TableId, const ColumnDescriptor * >

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)

bool	isLazyFetchColumn (const InputColDescriptor &col_desc)

const ColumnDescriptor *	getDeletedColForTable (const TableId table_id)

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 DeletedColumnsMap	deleted_columns_

const std::vector < InputTableInfo > &	query_infos_

const Executor *	executor_

Detailed Description

Definition at line 41 of file PlanState.h.

Member Typedef Documentation

using PlanState::ColumnId = int

Definition at line 43 of file PlanState.h.

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

Definition at line 44 of file PlanState.h.

using PlanState::TableId = int

Definition at line 42 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:62

PlanState::allow_lazy_fetch_

bool allow_lazy_fetch_

Definition: PlanState.h:61

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 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 TableId table_id )

inline

Definition at line 82 of file PlanState.h.

References deleted_columns_.

Referenced by Executor::buildIsDeletedCb().

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

Here is the caller graph for this function:

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()) << "Expected to find " << scan_col_desc;
   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 74 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);
   }