#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)

const std::unordered_set < shared::ColumnKey > &	getColumnsToFetch () const

const std::unordered_set < shared::ColumnKey > &	getColumnsToNotFetch () const

bool	isColumnToFetch (const shared::ColumnKey &column_key) const

bool	isColumnToNotFetch (const shared::ColumnKey &column_key) const

void	addColumnToFetch (const shared::ColumnKey &column_key, bool unmark_lazy_fetch=false)

void	addColumnToNotFetch (const shared::ColumnKey &column_key)

bool	hasExpressionNeedsLazyFetch (const std::vector< TargetExprCodegen > &target_exprs_to_codegen) const

void	registerNonLazyFetchExpression (const std::vector< TargetExprCodegen > &target_exprs_to_codegen)

Public Attributes
std::vector< int64_t >	init_agg_vals_

HoistedFiltersSet	hoisted_filters_

std::unordered_map < InputColDescriptor, size_t >	global_to_local_col_ids_

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_

Private Attributes
std::unordered_set < shared::ColumnKey >	columns_to_fetch_

std::unordered_set < shared::ColumnKey >	columns_to_not_fetch_

Detailed Description

Definition at line 43 of file PlanState.h.

Member Typedef Documentation

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

Definition at line 44 of file PlanState.h.

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

Definition at line 45 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 47 of file PlanState.h.

51 : allow_lazy_fetch_(allow_lazy_fetch)

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

PlanState::join_info_

JoinInfo join_info_

Definition: PlanState.h:63

PlanState::allow_lazy_fetch_

bool allow_lazy_fetch_

Definition: PlanState.h:62

Member Function Documentation

void PlanState::addColumnToFetch	(	const shared::ColumnKey &	column_key,
		bool	unmark_lazy_fetch = `false`
	)

Definition at line 124 of file PlanState.cpp.

References CHECK, columns_to_fetch_, columns_to_not_fetch_, and isColumnToNotFetch().

Referenced by CodeGenerator::codegenColVar(), getLocalColumnId(), anonymous_namespace{GeoIR.cpp}::mark_logical_column_to_fetch(), and registerNonLazyFetchExpression().

                                                          {
   if (unmark_lazy_fetch) {
     // This column was previously marked for lazy fetch but we now intentionally
     // mark it as non-lazy fetch column
     auto it = columns_to_not_fetch_.find(column_key);
     if (it != columns_to_not_fetch_.end()) {
       columns_to_not_fetch_.erase(it);
     }
   } else {
     if (columns_to_not_fetch_.count(column_key)) {
       // this case represents a query w/ fetching expressions with the order of
       // cv and an expression on it, i.e., SELECT col1, ST_NPoints(col1) FROM ...
       // since we first touch the cv itself and we forcely mark it as lazy-fetch
       // but to evaluate the expression, we must fetch the same cv;
       // so let's fetch the cv to allow evaluating the expression using the same cv
       throw CompilationRetryNoLazyFetch();
     }
   }
   CHECK(!isColumnToNotFetch(column_key)) << column_key;
   columns_to_fetch_.emplace(column_key);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanState::addColumnToNotFetch ( const shared::ColumnKey & column_key )

Definition at line 147 of file PlanState.cpp.

References CHECK, columns_to_not_fetch_, and isColumnToFetch().

Referenced by CodeGenerator::codegenColVar().

                                                                      {
   CHECK(!isColumnToFetch(column_key)) << column_key;
   columns_to_not_fetch_.emplace(column_key);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 95 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 93 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 40 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 55 of file PlanState.h.

55 {}

const std::unordered_set< shared::ColumnKey > & PlanState::getColumnsToFetch ( ) const

Definition at line 106 of file PlanState.cpp.

References columns_to_fetch_.

                                                                             {
   return columns_to_fetch_;
 }

const std::unordered_set< shared::ColumnKey > & PlanState::getColumnsToNotFetch ( ) const

Definition at line 110 of file PlanState.cpp.

References columns_to_not_fetch_.

                                                                                {
   return columns_to_not_fetch_;
 }

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

inline

Definition at line 85 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 52 of file PlanState.cpp.

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

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

                                                          {
   // Previously, we consider `rte_idx` of `col_var` w/ its column key together
   // to specify columns in the `global_to_local_col_ids_`.
   // But there is a case when the same col has multiple 'rte_idx's
   // For instance, the same geometry col is used not only as input col of the geo join op,
   // but also included as input col of filter predicate
   // In such a case, the same geometry col has two rte_idxs (the one defined by the filter
   // predicate and the other determined by the geo join operator)
   // The previous logic cannot cover this case b/c it allows only one `rte_idx` per col
   // But it is safe to share `rte_idx` of among all use cases of the same col
   CHECK(col_var);
   const auto& global_col_key = col_var->getColumnKey();
   InputColDescriptor scan_col_desc(global_col_key.column_id,
                                    global_col_key.table_id,
                                    global_col_key.db_id,
                                    col_var->get_rte_idx());
   std::optional<int> col_id{std::nullopt};
   // let's try to find col_id w/ considering `rte_idx`
   const auto it = global_to_local_col_ids_.find(scan_col_desc);
   if (it != global_to_local_col_ids_.end()) {
     // we have a valid col_id
     col_id = it->second;
   } else {
     // otherwise, let's try to find col_id for the same col
     // (but have different 'rte_idx') to share it w/ `col_var`
     for (auto const& kv : global_to_local_col_ids_) {
       if (kv.first.getColumnKey() == global_col_key) {
         col_id = kv.second;
         break;
       }
     }
   }
   if (col_id && *col_id >= 0) {
     if (fetch_column) {
       addColumnToFetch(global_col_key);
     }
     return *col_id;
   }
   CHECK(false) << "Expected to find " << global_col_key;
   return {};
 }

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 97 of file PlanState.h.

References simple_quals_.

Referenced by CodeGenerator::codegen().

                                                               {
     return simple_quals_;
   }

Here is the caller graph for this function:

bool PlanState::hasExpressionNeedsLazyFetch ( const std::vector< TargetExprCodegen > & target_exprs_to_codegen ) const

Definition at line 152 of file PlanState.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of().

Referenced by registerNonLazyFetchExpression().

                                                                        {
   return std::any_of(target_exprs_to_codegen.begin(),
                      target_exprs_to_codegen.end(),
                      [](const TargetExprCodegen& target_expr) {
                        return target_expr.target_info.sql_type.usesFlatBuffer();
                      });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool PlanState::isColumnToFetch ( const shared::ColumnKey & column_key ) const

Definition at line 114 of file PlanState.cpp.

References columns_to_fetch_, and shared::contains().

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

                                                                        {
   return shared::contains(columns_to_fetch_, column_key);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool PlanState::isColumnToNotFetch ( const shared::ColumnKey & column_key ) const

Definition at line 118 of file PlanState.cpp.

References columns_to_not_fetch_, and shared::contains().

Referenced by addColumnToFetch().

                                                                           {
   return shared::contains(columns_to_not_fetch_, column_key);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 22 of file PlanState.cpp.

References allow_lazy_fetch_, columns_to_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;
     }
   }
   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 77 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);
   }

Here is the call graph for this function:

PlanState::query_infos_ ( query_infos )

void PlanState::registerNonLazyFetchExpression ( const std::vector< TargetExprCodegen > & target_exprs_to_codegen )

Definition at line 161 of file PlanState.cpp.

References addColumnToFetch(), and hasExpressionNeedsLazyFetch().

                                                                  {
   auto const needs_lazy_fetch = hasExpressionNeedsLazyFetch(target_exprs_to_codegen);
   for (const auto& expr : target_exprs_to_codegen) {
     if (needs_lazy_fetch && !expr.target_info.sql_type.usesFlatBuffer()) {
       if (auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr.target_expr)) {
         // force non-lazy fetch on all other columns that don't support flatbuffer
         addColumnToFetch(col_var->getColumnKey(), /*unmark_lazy_fetch=*/true);
       }
     }
   }
 }