anonymous_namespace{RelAlgExecutor.cpp} Namespace Reference

Namespaces
	anonymous_namespace{RelAlgExecutor.cpp}

Classes
class	RexUsedInputsVisitor
struct	ErrorInfo

Functions
bool	node_is_aggregate (const RelAlgNode *ra)
std::unordered_set< PhysicalInput >	get_physical_inputs_with_spi_col_id (const RelAlgNode *ra)
void	set_parallelism_hints (const RelAlgNode &ra_node)
void	prepare_string_dictionaries (const RelAlgNode &ra_node)
void	prepare_foreign_table_for_execution (const RelAlgNode &ra_node)
void	prepare_for_system_table_execution (const RelAlgNode &ra_node, const CompilationOptions &co)
bool	has_valid_query_plan_dag (const RelAlgNode *node)
void	check_none_encoded_string_cast_tuple_limit (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
void	check_sort_node_source_constraint (const RelSort *sort)
void	handle_query_hint (RegisteredQueryHint const &query_hints, ExecutionOptions &eo, CompilationOptions &co)
const RelAlgNode *	get_data_sink (const RelAlgNode *ra_node)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelCompound *compound)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelAggregate *aggregate)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelProject *project)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelTableFunction *table_func)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelFilter *filter)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_used_inputs (const RelLogicalUnion *logical_union)
shared::TableKey	table_key_from_ra (const RelAlgNode *ra_node)
std::unordered_map< const RelAlgNode *, int >	get_input_nest_levels (const RelAlgNode *ra_node, const std::vector< size_t > &input_permutation)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	get_join_source_used_inputs (const RelAlgNode *ra_node)
void	collect_used_input_desc (std::vector< InputDescriptor > &input_descs, std::unordered_set< std::shared_ptr< const InputColDescriptor >> &input_col_descs_unique, const RelAlgNode *ra_node, const std::unordered_set< const RexInput * > &source_used_inputs, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)
template<class RA >
std::pair< std::vector < InputDescriptor >, std::list < std::shared_ptr< const InputColDescriptor > > >	get_input_desc_impl (const RA *ra_node, const std::unordered_set< const RexInput * > &used_inputs, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const std::vector< size_t > &input_permutation)
template<class RA >
std::tuple< std::vector < InputDescriptor >, std::list < std::shared_ptr< const InputColDescriptor > >, std::vector < std::shared_ptr< RexInput > > >	get_input_desc (const RA *ra_node, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const std::vector< size_t > &input_permutation)
size_t	get_scalar_sources_size (const RelCompound *compound)
size_t	get_scalar_sources_size (const RelProject *project)
size_t	get_scalar_sources_size (const RelTableFunction *table_func)
const RexScalar *	scalar_at (const size_t i, const RelCompound *compound)
const RexScalar *	scalar_at (const size_t i, const RelProject *project)
const RexScalar *	scalar_at (const size_t i, const RelTableFunction *table_func)
std::shared_ptr< Analyzer::Expr >	set_transient_dict (const std::shared_ptr< Analyzer::Expr > expr)
void	set_transient_dict_maybe (std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::shared_ptr< Analyzer::Expr > &expr)
std::shared_ptr< Analyzer::Expr >	cast_dict_to_none (const std::shared_ptr< Analyzer::Expr > &input)
template<class RA >
std::vector< std::shared_ptr < Analyzer::Expr > >	translate_scalar_sources (const RA *ra_node, const RelAlgTranslator &translator, const ::ExecutorType executor_type)
template<class RA >
std::vector< std::shared_ptr < Analyzer::Expr > >	translate_scalar_sources_for_update (const RA *ra_node, const RelAlgTranslator &translator, int32_t tableId, const Catalog_Namespace::Catalog &cat, const ColumnNameList &colNames, size_t starting_projection_column_idx)
std::list< std::shared_ptr < Analyzer::Expr > >	translate_groupby_exprs (const RelCompound *compound, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
std::list< std::shared_ptr < Analyzer::Expr > >	translate_groupby_exprs (const RelAggregate *aggregate, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
QualsConjunctiveForm	translate_quals (const RelCompound *compound, const RelAlgTranslator &translator)
std::vector< Analyzer::Expr * >	translate_targets (std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned, std::unordered_map< size_t, SQLTypeInfo > &target_exprs_type_infos, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const RelCompound *compound, const RelAlgTranslator &translator, const ExecutorType executor_type)
std::vector< Analyzer::Expr * >	translate_targets (std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned, std::unordered_map< size_t, SQLTypeInfo > &target_exprs_type_infos, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const RelAggregate *aggregate, const RelAlgTranslator &translator)
bool	is_count_distinct (const Analyzer::Expr *expr)
bool	is_agg (const Analyzer::Expr *expr)
SQLTypeInfo	get_logical_type_for_expr (const Analyzer::Expr &expr)
template<class RA >
std::vector< TargetMetaInfo >	get_targets_meta (const RA *ra_node, const std::vector< Analyzer::Expr * > &target_exprs)
template<>
std::vector< TargetMetaInfo >	get_targets_meta (const RelFilter *filter, const std::vector< Analyzer::Expr * > &target_exprs)
bool	is_window_execution_unit (const RelAlgExecutionUnit &ra_exe_unit)
std::shared_ptr< Analyzer::Expr >	transform_to_inner (const Analyzer::Expr *expr)
template<class T >
int64_t	insert_one_dict_str (T *col_data, const std::string &columnName, const SQLTypeInfo &columnType, const Analyzer::Constant *col_cv, const Catalog_Namespace::Catalog &catalog)
template<class T >
int64_t	insert_one_dict_str (T *col_data, const ColumnDescriptor *cd, const Analyzer::Constant *col_cv, const Catalog_Namespace::Catalog &catalog)
size_t	get_limit_value (std::optional< size_t > limit)
size_t	get_scan_limit (const RelAlgNode *ra, std::optional< size_t > limit)
bool	first_oe_is_desc (const std::list< Analyzer::OrderEntry > &order_entries)
size_t	groups_approx_upper_bound (const std::vector< InputTableInfo > &table_infos)
bool	is_projection (const RelAlgExecutionUnit &ra_exe_unit)
bool	can_output_columnar (const RelAlgExecutionUnit &ra_exe_unit, const RenderInfo *render_info, const RelAlgNode *body)
bool	should_output_columnar (const RelAlgExecutionUnit &ra_exe_unit)
bool	compute_output_buffer_size (const RelAlgExecutionUnit &ra_exe_unit)
bool	exe_unit_has_quals (const RelAlgExecutionUnit ra_exe_unit)
RelAlgExecutionUnit	decide_approx_count_distinct_implementation (const RelAlgExecutionUnit &ra_exe_unit_in, const std::vector< InputTableInfo > &table_infos, const Executor *executor, const ExecutorDeviceType device_type_in, std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned)
bool	can_use_bump_allocator (const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo)
ErrorInfo	getErrorDescription (const int32_t error_code)
JoinType	get_join_type (const RelAlgNode *ra)
std::unique_ptr< const RexOperator >	get_bitwise_equals (const RexScalar *scalar)
std::unique_ptr< const RexOperator >	get_bitwise_equals_conjunction (const RexScalar *scalar)
std::vector< JoinType >	left_deep_join_types (const RelLeftDeepInnerJoin *left_deep_join)
template<class RA >
std::vector< size_t >	do_table_reordering (std::vector< InputDescriptor > &input_descs, std::list< std::shared_ptr< const InputColDescriptor >> &input_col_descs, const JoinQualsPerNestingLevel &left_deep_join_quals, std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const RA *node, const std::vector< InputTableInfo > &query_infos, const Executor *executor)
std::vector< size_t >	get_left_deep_join_input_sizes (const RelLeftDeepInnerJoin *left_deep_join)
std::list< std::shared_ptr < Analyzer::Expr > >	rewrite_quals (const std::list< std::shared_ptr< Analyzer::Expr >> &quals)
std::vector< const RexScalar * >	rex_to_conjunctive_form (const RexScalar *qual_expr)
std::shared_ptr< Analyzer::Expr >	build_logical_expression (const std::vector< std::shared_ptr< Analyzer::Expr >> &factors, const SQLOps sql_op)
template<class QualsList >
bool	list_contains_expression (const QualsList &haystack, const std::shared_ptr< Analyzer::Expr > &needle)
std::shared_ptr< Analyzer::Expr >	reverse_logical_distribution (const std::shared_ptr< Analyzer::Expr > &expr)
std::vector< std::shared_ptr < Analyzer::Expr > >	synthesize_inputs (const RelAlgNode *ra_node, const size_t nest_level, const std::vector< TargetMetaInfo > &in_metainfo, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)
std::vector< Analyzer::Expr * >	get_raw_pointers (std::vector< std::shared_ptr< Analyzer::Expr >> const &input)
std::vector< std::shared_ptr < Analyzer::Expr > >	target_exprs_for_union (RelAlgNode const *input_node)
std::pair< std::vector < TargetMetaInfo > , std::vector< std::shared_ptr < Analyzer::Expr > > >	get_inputs_meta (const RelFilter *filter, const RelAlgTranslator &translator, const std::vector< std::shared_ptr< RexInput >> &inputs_owned, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)

Function Documentation

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgExecutor.cpp}::build_logical_expression	(	const std::vector< std::shared_ptr< Analyzer::Expr >> &	factors,
		const SQLOps	sql_op
	)

Definition at line 4609 of file RelAlgExecutor.cpp.

References CHECK, kONE, and Parser::OperExpr::normalize().

Referenced by reverse_logical_distribution().

                         {
  CHECK(!factors.empty());
  auto acc = factors.front();
  for (size_t i = 1; i < factors.size(); ++i) {
    acc = Parser::OperExpr::normalize(sql_op, kONE, acc, factors[i]);
  }
  return acc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::can_output_columnar	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const RenderInfo *	render_info,
		const RelAlgNode *	body
	)

Definition at line 3483 of file RelAlgExecutor.cpp.

References is_projection(), heavyai::InSituFlagsOwnerInterface::isInSitu(), SortInfo::order_entries, RelAlgExecutionUnit::sort_info, and RelAlgExecutionUnit::target_exprs.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                 {
  if (!is_projection(ra_exe_unit)) {
    return false;
  }
  if (render_info && render_info->isInSitu()) {
    return false;
  }
  if (!ra_exe_unit.sort_info.order_entries.empty()) {
    // disable output columnar when we have top-sort node query
    return false;
  }
  bool flatbuffer_is_used = false;
  for (const auto& target_expr : ra_exe_unit.target_exprs) {
    const auto ti = target_expr->get_type_info();
    // Usage of FlatBuffer memory layout implies columnar-only support.
    if (ti.usesFlatBuffer()) {
      flatbuffer_is_used = true;
      continue;
    }
    // We don't currently support varlen columnar projections, so
    // return false if we find one
    // TODO: notice that currently ti.supportsFlatBuffer() == ti.is_varlen()
    if (ti.is_varlen()) {
      return false;
    }
  }
  if (auto top_project = dynamic_cast<const RelProject*>(body)) {
    if (top_project->isRowwiseOutputForced()) {
      if (flatbuffer_is_used) {
        throw std::runtime_error(
            "Cannot force rowwise output when FlatBuffer layout is used.");
      }
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::can_use_bump_allocator ( const RelAlgExecutionUnit &  ra_exe_unit, const CompilationOptions &  co, const ExecutionOptions &  eo  )

inline

Definition at line 3630 of file RelAlgExecutor.cpp.

References CompilationOptions::device_type, g_enable_bump_allocator, GPU, SortInfo::order_entries, ExecutionOptions::output_columnar_hint, and RelAlgExecutionUnit::sort_info.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                               {
  return g_enable_bump_allocator && (co.device_type == ExecutorDeviceType::GPU) &&
         !eo.output_columnar_hint && ra_exe_unit.sort_info.order_entries.empty();
}

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgExecutor.cpp}::cast_dict_to_none

(

const std::shared_ptr< Analyzer::Expr > &

input

)

Definition at line 1738 of file RelAlgExecutor.cpp.

References kENCODING_DICT, and kTEXT.

Referenced by translate_scalar_sources(), and translate_targets().

                                              {
  const auto& input_ti = input->get_type_info();
  if (input_ti.is_string() && input_ti.get_compression() == kENCODING_DICT) {
    return input->add_cast(SQLTypeInfo(kTEXT, input_ti.get_notnull()));
  }
  return input;
}

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::check_none_encoded_string_cast_tuple_limit	(	const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

Definition at line 447 of file RelAlgExecutor.cpp.

References gpu_enabled::accumulate(), g_enable_watchdog, g_watchdog_none_encoded_string_translation_limit, and get_text_cast_counts().

Referenced by RelAlgExecutor::executeWorkUnit().

                                            {
  if (!g_enable_watchdog) {
    return;
  }
  auto const tuples_upper_bound =
      std::accumulate(query_infos.cbegin(),
                      query_infos.cend(),
                      size_t(0),
                      [](auto max, auto const& query_info) {
                        return std::max(max, query_info.info.getNumTuples());
                      });
  if (tuples_upper_bound <= g_watchdog_none_encoded_string_translation_limit) {
    return;
  }

  const auto& text_cast_counts = get_text_cast_counts(ra_exe_unit);
  const bool has_text_casts =
      text_cast_counts.text_decoding_casts + text_cast_counts.text_encoding_casts > 0UL;

  if (!has_text_casts) {
    return;
  }
  std::ostringstream oss;
  oss << "Query requires one or more casts between none-encoded and dictionary-encoded "
      << "strings, and the estimated table size (" << tuples_upper_bound << " rows) "
      << "exceeds the configured watchdog none-encoded string translation limit of "
      << g_watchdog_none_encoded_string_translation_limit << " rows.";
  throw std::runtime_error(oss.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::check_sort_node_source_constraint ( const RelSort *  sort )

inline

Definition at line 794 of file RelAlgExecutor.cpp.

References CHECK_EQ, RelAlgNode::getInput(), and RelAlgNode::inputCount().

Referenced by RelAlgExecutor::executeRelAlgQuerySingleStep(), and RelAlgExecutor::executeSort().

                                                                   {
  CHECK_EQ(size_t(1), sort->inputCount());
  const auto source = sort->getInput(0);
  if (dynamic_cast<const RelSort*>(source)) {
    throw std::runtime_error("Sort node not supported as input to another sort");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::collect_used_input_desc	(	std::vector< InputDescriptor > &	input_descs,
		std::unordered_set< std::shared_ptr< const InputColDescriptor >> &	input_col_descs_unique,
		const RelAlgNode *	ra_node,
		const std::unordered_set< const RexInput * > &	source_used_inputs,
		const std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level
	)

Definition at line 1595 of file RelAlgExecutor.cpp.

References RelRexToStringConfig::defaults(), table_key_from_ra(), RelAlgNode::toString(), and VLOG.

Referenced by get_input_desc_impl().

                                                                         {
  VLOG(3) << "ra_node=" << ra_node->toString(RelRexToStringConfig::defaults())
          << " input_col_descs_unique.size()=" << input_col_descs_unique.size()
          << " source_used_inputs.size()=" << source_used_inputs.size();
  for (const auto used_input : source_used_inputs) {
    const auto input_ra = used_input->getSourceNode();
    const auto table_key = table_key_from_ra(input_ra);
    auto col_id = used_input->getIndex();
    auto it = input_to_nest_level.find(input_ra);
    if (it != input_to_nest_level.end()) {
      const int nest_level = it->second;
      if (auto rel_scan = dynamic_cast<const RelScan*>(input_ra)) {
        const auto& catalog = rel_scan->getCatalog();
        col_id = catalog.getColumnIdBySpi(table_key.table_id, col_id + 1);
      }
      input_col_descs_unique.insert(std::make_shared<const InputColDescriptor>(
          col_id, table_key.table_id, table_key.db_id, nest_level));
    } else if (!dynamic_cast<const RelLogicalUnion*>(ra_node)) {
      throw std::runtime_error("Bushy joins not supported");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::compute_output_buffer_size

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Determines whether a query needs to compute the size of its output buffer. Returns true for projection queries with no LIMIT or a LIMIT that exceeds the high scan limit threshold (meaning it would be cheaper to compute the number of rows passing or use the bump allocator than allocate the current scan limit per GPU)

Definition at line 3540 of file RelAlgExecutor.cpp.

References RelAlgExecutionUnit::groupby_exprs, Executor::high_scan_limit, RelAlgExecutionUnit::scan_limit, and RelAlgExecutionUnit::target_exprs.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                        {
  for (const auto target_expr : ra_exe_unit.target_exprs) {
    if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
      return false;
    }
  }
  if (ra_exe_unit.groupby_exprs.size() == 1 && !ra_exe_unit.groupby_exprs.front() &&
      (!ra_exe_unit.scan_limit || ra_exe_unit.scan_limit > Executor::high_scan_limit)) {
    return true;
  }
  return false;
}

Here is the caller graph for this function:

RelAlgExecutionUnit anonymous_namespace{RelAlgExecutor.cpp}::decide_approx_count_distinct_implementation	(	const RelAlgExecutionUnit &	ra_exe_unit_in,
		const std::vector< InputTableInfo > &	table_infos,
		const Executor *	executor,
		const ExecutorDeviceType	device_type_in,
		std::vector< std::shared_ptr< Analyzer::Expr >> &	target_exprs_owned
	)

Definition at line 3558 of file RelAlgExecutor.cpp.

References Bitmap, CHECK, CHECK_GE, g_bigint_count, g_cluster, g_hll_precision_bits, get_agg_type(), get_count_distinct_sub_bitmap_count(), get_target_info(), getExpressionRange(), GPU, hll_size_for_rate(), Integer, kAPPROX_COUNT_DISTINCT, kCOUNT, kENCODING_DICT, kINT, and RelAlgExecutionUnit::target_exprs.

Referenced by RelAlgExecutor::executeWorkUnit(), and RelAlgExecutor::handleOutOfMemoryRetry().

                                                                {
  RelAlgExecutionUnit ra_exe_unit = ra_exe_unit_in;
  for (size_t i = 0; i < ra_exe_unit.target_exprs.size(); ++i) {
    const auto target_expr = ra_exe_unit.target_exprs[i];
    const auto agg_info = get_target_info(target_expr, g_bigint_count);
    if (agg_info.agg_kind != kAPPROX_COUNT_DISTINCT) {
      continue;
    }
    CHECK(dynamic_cast<const Analyzer::AggExpr*>(target_expr));
    const auto arg = static_cast<Analyzer::AggExpr*>(target_expr)->get_own_arg();
    CHECK(arg);
    const auto& arg_ti = arg->get_type_info();
    // Avoid calling getExpressionRange for variable length types (string and array),
    // it'd trigger an assertion since that API expects to be called only for types
    // for which the notion of range is well-defined. A bit of a kludge, but the
    // logic to reject these types anyway is at lower levels in the stack and not
    // really worth pulling into a separate function for now.
    if (!(arg_ti.is_number() || arg_ti.is_boolean() || arg_ti.is_time() ||
          (arg_ti.is_string() && arg_ti.get_compression() == kENCODING_DICT))) {
      continue;
    }
    const auto arg_range = getExpressionRange(arg.get(), table_infos, executor);
    if (arg_range.getType() != ExpressionRangeType::Integer) {
      continue;
    }
    // When running distributed, the threshold for using the precise implementation
    // must be consistent across all leaves, otherwise we could have a mix of precise
    // and approximate bitmaps and we cannot aggregate them.
    const auto device_type = g_cluster ? ExecutorDeviceType::GPU : device_type_in;
    const auto bitmap_sz_bits = arg_range.getIntMax() - arg_range.getIntMin() + 1;
    const auto sub_bitmap_count =
        get_count_distinct_sub_bitmap_count(bitmap_sz_bits, ra_exe_unit, device_type);
    int64_t approx_bitmap_sz_bits{0};
    const auto error_rate_expr = static_cast<Analyzer::AggExpr*>(target_expr)->get_arg1();
    if (error_rate_expr) {
      CHECK(error_rate_expr->get_type_info().get_type() == kINT);
      auto const error_rate =
          dynamic_cast<Analyzer::Constant const*>(error_rate_expr.get());
      CHECK(error_rate);
      CHECK_GE(error_rate->get_constval().intval, 1);
      approx_bitmap_sz_bits = hll_size_for_rate(error_rate->get_constval().intval);
    } else {
      approx_bitmap_sz_bits = g_hll_precision_bits;
    }
    CountDistinctDescriptor approx_count_distinct_desc{CountDistinctImplType::Bitmap,
                                                       arg_range.getIntMin(),
                                                       approx_bitmap_sz_bits,
                                                       true,
                                                       device_type,
                                                       sub_bitmap_count};
    CountDistinctDescriptor precise_count_distinct_desc{CountDistinctImplType::Bitmap,
                                                        arg_range.getIntMin(),
                                                        bitmap_sz_bits,
                                                        false,
                                                        device_type,
                                                        sub_bitmap_count};
    if (approx_count_distinct_desc.bitmapPaddedSizeBytes() >=
        precise_count_distinct_desc.bitmapPaddedSizeBytes()) {
      auto precise_count_distinct = makeExpr<Analyzer::AggExpr>(
          get_agg_type(kCOUNT, arg.get()), kCOUNT, arg, true, nullptr);
      target_exprs_owned.push_back(precise_count_distinct);
      ra_exe_unit.target_exprs[i] = precise_count_distinct.get();
    }
  }
  return ra_exe_unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::vector<size_t> anonymous_namespace{RelAlgExecutor.cpp}::do_table_reordering	(	std::vector< InputDescriptor > &	input_descs,
		std::list< std::shared_ptr< const InputColDescriptor >> &	input_col_descs,
		const JoinQualsPerNestingLevel &	left_deep_join_quals,
		std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level,
		const RA *	node,
		const std::vector< InputTableInfo > &	query_infos,
		const Executor *	executor
	)

Definition at line 4400 of file RelAlgExecutor.cpp.

References CHECK, g_cluster, get_input_desc(), get_input_nest_levels(), Catalog_Namespace::get_metadata_for_table(), get_node_input_permutation(), and table_is_replicated().

Referenced by RelAlgExecutor::createCompoundWorkUnit(), and RelAlgExecutor::createProjectWorkUnit().

                              {
  if (g_cluster) {
    // Disable table reordering in distributed mode. The aggregator does not have enough
    // information to break ties
    return {};
  }
  if (node->isUpdateViaSelect() || node->isDeleteViaSelect()) {
    // Do not reorder tables for UPDATE and DELETE queries, since the outer table always
    // has to be the physical table.
    return {};
  }
  for (const auto& table_info : query_infos) {
    if (table_info.table_key.table_id < 0) {
      continue;
    }
    const auto td = Catalog_Namespace::get_metadata_for_table(table_info.table_key);
    CHECK(td);
    if (table_is_replicated(td)) {
      return {};
    }
  }
  const auto input_permutation =
      get_node_input_permutation(left_deep_join_quals, query_infos, executor);
  input_to_nest_level = get_input_nest_levels(node, input_permutation);
  std::tie(input_descs, input_col_descs, std::ignore) =
      get_input_desc(node, input_to_nest_level, input_permutation);
  return input_permutation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::exe_unit_has_quals ( const RelAlgExecutionUnit  ra_exe_unit )

inline

Definition at line 3553 of file RelAlgExecutor.cpp.

References RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, and RelAlgExecutionUnit::simple_quals.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                      {
  return !(ra_exe_unit.quals.empty() && ra_exe_unit.join_quals.empty() &&
           ra_exe_unit.simple_quals.empty());
}

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::first_oe_is_desc

(

const std::list< Analyzer::OrderEntry > &

order_entries

)

Definition at line 3211 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::createSortInputWorkUnit(), and RelAlgExecutor::executeSort().

                                                                        {
  return !order_entries.empty() && order_entries.front().is_desc;
}

Here is the caller graph for this function:

std::unique_ptr<const RexOperator> anonymous_namespace{RelAlgExecutor.cpp}::get_bitwise_equals

(

const RexScalar *

scalar

)

Definition at line 4315 of file RelAlgExecutor.cpp.

References CHECK_EQ, kAND, kBW_EQ, kEQ, kISNULL, kOR, and RexVisitorBase< T >::visit().

Referenced by get_bitwise_equals_conjunction().

                                                                             {
  const auto condition = dynamic_cast<const RexOperator*>(scalar);
  if (!condition || condition->getOperator() != kOR || condition->size() != 2) {
    return nullptr;
  }
  const auto equi_join_condition =
      dynamic_cast<const RexOperator*>(condition->getOperand(0));
  if (!equi_join_condition || equi_join_condition->getOperator() != kEQ) {
    return nullptr;
  }
  const auto both_are_null_condition =
      dynamic_cast<const RexOperator*>(condition->getOperand(1));
  if (!both_are_null_condition || both_are_null_condition->getOperator() != kAND ||
      both_are_null_condition->size() != 2) {
    return nullptr;
  }
  const auto lhs_is_null =
      dynamic_cast<const RexOperator*>(both_are_null_condition->getOperand(0));
  const auto rhs_is_null =
      dynamic_cast<const RexOperator*>(both_are_null_condition->getOperand(1));
  if (!lhs_is_null || !rhs_is_null || lhs_is_null->getOperator() != kISNULL ||
      rhs_is_null->getOperator() != kISNULL) {
    return nullptr;
  }
  CHECK_EQ(size_t(1), lhs_is_null->size());
  CHECK_EQ(size_t(1), rhs_is_null->size());
  CHECK_EQ(size_t(2), equi_join_condition->size());
  const auto eq_lhs = dynamic_cast<const RexInput*>(equi_join_condition->getOperand(0));
  const auto eq_rhs = dynamic_cast<const RexInput*>(equi_join_condition->getOperand(1));
  const auto is_null_lhs = dynamic_cast<const RexInput*>(lhs_is_null->getOperand(0));
  const auto is_null_rhs = dynamic_cast<const RexInput*>(rhs_is_null->getOperand(0));
  if (!eq_lhs || !eq_rhs || !is_null_lhs || !is_null_rhs) {
    return nullptr;
  }
  std::vector<std::unique_ptr<const RexScalar>> eq_operands;
  if (*eq_lhs == *is_null_lhs && *eq_rhs == *is_null_rhs) {
    RexDeepCopyVisitor deep_copy_visitor;
    auto lhs_op_copy = deep_copy_visitor.visit(equi_join_condition->getOperand(0));
    auto rhs_op_copy = deep_copy_visitor.visit(equi_join_condition->getOperand(1));
    eq_operands.emplace_back(lhs_op_copy.release());
    eq_operands.emplace_back(rhs_op_copy.release());
    return boost::make_unique<const RexOperator>(
        kBW_EQ, eq_operands, equi_join_condition->getType());
  }
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexOperator> anonymous_namespace{RelAlgExecutor.cpp}::get_bitwise_equals_conjunction

(

const RexScalar *

scalar

)

Definition at line 4362 of file RelAlgExecutor.cpp.

References CHECK_GE, get_bitwise_equals(), and kAND.

Referenced by RelAlgExecutor::makeJoinQuals().

                             {
  const auto condition = dynamic_cast<const RexOperator*>(scalar);
  if (condition && condition->getOperator() == kAND) {
    CHECK_GE(condition->size(), size_t(2));
    auto acc = get_bitwise_equals(condition->getOperand(0));
    if (!acc) {
      return nullptr;
    }
    for (size_t i = 1; i < condition->size(); ++i) {
      std::vector<std::unique_ptr<const RexScalar>> and_operands;
      and_operands.emplace_back(std::move(acc));
      and_operands.emplace_back(get_bitwise_equals_conjunction(condition->getOperand(i)));
      acc =
          boost::make_unique<const RexOperator>(kAND, and_operands, condition->getType());
    }
    return acc;
  }
  return get_bitwise_equals(scalar);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const RelAlgNode* anonymous_namespace{RelAlgExecutor.cpp}::get_data_sink

(

const RelAlgNode *

ra_node

)

Definition at line 1390 of file RelAlgExecutor.cpp.

References CHECK_EQ, RelAlgNode::getInput(), RelAlgNode::inputCount(), and join().

Referenced by get_input_desc_impl(), get_input_nest_levels(), get_inputs_meta(), get_join_source_used_inputs(), get_join_type(), and get_used_inputs().

                                                           {
  if (auto table_func = dynamic_cast<const RelTableFunction*>(ra_node)) {
    return table_func;
  }
  if (auto join = dynamic_cast<const RelJoin*>(ra_node)) {
    CHECK_EQ(size_t(2), join->inputCount());
    return join;
  }
  if (!dynamic_cast<const RelLogicalUnion*>(ra_node)) {
    CHECK_EQ(size_t(1), ra_node->inputCount());
  }
  auto only_src = ra_node->getInput(0);
  const bool is_join = dynamic_cast<const RelJoin*>(only_src) ||
                       dynamic_cast<const RelLeftDeepInnerJoin*>(only_src);
  return is_join ? only_src : ra_node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::tuple<std::vector<InputDescriptor>, std::list<std::shared_ptr<const InputColDescriptor> >, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_input_desc	(	const RA *	ra_node,
		const std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level,
		const std::vector< size_t > &	input_permutation
	)

Definition at line 1677 of file RelAlgExecutor.cpp.

References get_input_desc_impl(), get_used_inputs(), and VLOG.

Referenced by RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createTableFunctionWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), and do_table_reordering().

                                                           {
  std::unordered_set<const RexInput*> used_inputs;
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned;
  std::tie(used_inputs, used_inputs_owned) = get_used_inputs(ra_node);
  VLOG(3) << "used_inputs.size() = " << used_inputs.size();
  auto input_desc_pair =
      get_input_desc_impl(ra_node, used_inputs, input_to_nest_level, input_permutation);
  return std::make_tuple(
      input_desc_pair.first, input_desc_pair.second, used_inputs_owned);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::pair<std::vector<InputDescriptor>, std::list<std::shared_ptr<const InputColDescriptor> > > anonymous_namespace{RelAlgExecutor.cpp}::get_input_desc_impl	(	const RA *	ra_node,
		const std::unordered_set< const RexInput * > &	used_inputs,
		const std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level,
		const std::vector< size_t > &	input_permutation
	)

Definition at line 1626 of file RelAlgExecutor.cpp.

References collect_used_input_desc(), get_data_sink(), get_join_source_used_inputs(), gpu_enabled::sort(), and table_key_from_ra().

Referenced by get_input_desc().

                                                                {
  std::vector<InputDescriptor> input_descs;
  const auto data_sink_node = get_data_sink(ra_node);
  for (size_t input_idx = 0; input_idx < data_sink_node->inputCount(); ++input_idx) {
    const auto input_node_idx =
        input_permutation.empty() ? input_idx : input_permutation[input_idx];
    auto input_ra = data_sink_node->getInput(input_node_idx);
    const auto table_key = table_key_from_ra(input_ra);
    input_descs.emplace_back(table_key.db_id, table_key.table_id, input_idx);
  }
  std::unordered_set<std::shared_ptr<const InputColDescriptor>> input_col_descs_unique;
  collect_used_input_desc(input_descs,
                          input_col_descs_unique,  // modified
                          ra_node,
                          used_inputs,
                          input_to_nest_level);
  std::unordered_set<const RexInput*> join_source_used_inputs;
  std::vector<std::shared_ptr<RexInput>> join_source_used_inputs_owned;
  std::tie(join_source_used_inputs, join_source_used_inputs_owned) =
      get_join_source_used_inputs(ra_node);
  collect_used_input_desc(input_descs,
                          input_col_descs_unique,  // modified
                          ra_node,
                          join_source_used_inputs,
                          input_to_nest_level);
  std::vector<std::shared_ptr<const InputColDescriptor>> input_col_descs(
      input_col_descs_unique.begin(), input_col_descs_unique.end());

  std::sort(input_col_descs.begin(),
            input_col_descs.end(),
            [](std::shared_ptr<const InputColDescriptor> const& lhs,
               std::shared_ptr<const InputColDescriptor> const& rhs) {
              return std::make_tuple(lhs->getScanDesc().getNestLevel(),
                                     lhs->getColId(),
                                     lhs->getScanDesc().getTableKey()) <
                     std::make_tuple(rhs->getScanDesc().getNestLevel(),
                                     rhs->getColId(),
                                     rhs->getScanDesc().getTableKey());
            });
  return {input_descs,
          std::list<std::shared_ptr<const InputColDescriptor>>(input_col_descs.begin(),
                                                               input_col_descs.end())};
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unordered_map<const RelAlgNode*, int> anonymous_namespace{RelAlgExecutor.cpp}::get_input_nest_levels	(	const RelAlgNode *	ra_node,
		const std::vector< size_t > &	input_permutation
	)

Definition at line 1528 of file RelAlgExecutor.cpp.

References CHECK, logger::DEBUG1, RelRexToStringConfig::defaults(), get_data_sink(), and LOG_IF.

Referenced by RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createTableFunctionWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), do_table_reordering(), and RelAlgExecutor::getRelAlgTranslator().

                                                {
  const auto data_sink_node = get_data_sink(ra_node);
  std::unordered_map<const RelAlgNode*, int> input_to_nest_level;
  for (size_t input_idx = 0; input_idx < data_sink_node->inputCount(); ++input_idx) {
    const auto input_node_idx =
        input_permutation.empty() ? input_idx : input_permutation[input_idx];
    const auto input_ra = data_sink_node->getInput(input_node_idx);
    // Having a non-zero mapped value (input_idx) results in the query being interpretted
    // as a JOIN within CodeGenerator::codegenColVar() due to rte_idx being set to the
    // mapped value (input_idx) which originates here. This would be incorrect for UNION.
    size_t const idx = dynamic_cast<const RelLogicalUnion*>(ra_node) ? 0 : input_idx;
    const auto it_ok = input_to_nest_level.emplace(input_ra, idx);
    CHECK(it_ok.second);
    LOG_IF(DEBUG1, !input_permutation.empty())
        << "Assigned input " << input_ra->toString(RelRexToStringConfig::defaults())
        << " to nest level " << input_idx;
  }
  return input_to_nest_level;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<std::vector<TargetMetaInfo>, std::vector<std::shared_ptr<Analyzer::Expr> > > anonymous_namespace{RelAlgExecutor.cpp}::get_inputs_meta	(	const RelFilter *	filter,
		const RelAlgTranslator &	translator,
		const std::vector< std::shared_ptr< RexInput >> &	inputs_owned,
		const std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level
	)

Definition at line 5306 of file RelAlgExecutor.cpp.

References CHECK, get_data_sink(), get_raw_pointers(), get_targets_meta(), synthesize_inputs(), and RelAlgTranslator::translate().

Referenced by RelAlgExecutor::createFilterWorkUnit().

                                                                                     {
  std::vector<TargetMetaInfo> in_metainfo;
  std::vector<std::shared_ptr<Analyzer::Expr>> exprs_owned;
  const auto data_sink_node = get_data_sink(filter);
  auto input_it = inputs_owned.begin();
  for (size_t nest_level = 0; nest_level < data_sink_node->inputCount(); ++nest_level) {
    const auto source = data_sink_node->getInput(nest_level);
    const auto scan_source = dynamic_cast<const RelScan*>(source);
    if (scan_source) {
      CHECK(source->getOutputMetainfo().empty());
      std::vector<std::shared_ptr<Analyzer::Expr>> scalar_sources_owned;
      for (size_t i = 0; i < scan_source->size(); ++i, ++input_it) {
        scalar_sources_owned.push_back(translator.translate(input_it->get()));
      }
      const auto source_metadata =
          get_targets_meta(scan_source, get_raw_pointers(scalar_sources_owned));
      in_metainfo.insert(
          in_metainfo.end(), source_metadata.begin(), source_metadata.end());
      exprs_owned.insert(
          exprs_owned.end(), scalar_sources_owned.begin(), scalar_sources_owned.end());
    } else {
      const auto& source_metadata = source->getOutputMetainfo();
      input_it += source_metadata.size();
      in_metainfo.insert(
          in_metainfo.end(), source_metadata.begin(), source_metadata.end());
      const auto scalar_sources_owned = synthesize_inputs(
          data_sink_node, nest_level, source_metadata, input_to_nest_level);
      exprs_owned.insert(
          exprs_owned.end(), scalar_sources_owned.begin(), scalar_sources_owned.end());
    }
  }
  return std::make_pair(in_metainfo, exprs_owned);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_join_source_used_inputs

(

const RelAlgNode *

ra_node

)

Definition at line 1551 of file RelAlgExecutor.cpp.

References CHECK_EQ, CHECK_GE, CHECK_GT, RelRexToStringConfig::defaults(), get_data_sink(), anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor::get_inputs_owned(), RelAlgNode::inputCount(), join(), run_benchmark_import::result, and RelAlgNode::toString().

Referenced by get_input_desc_impl().

                                                       {
  const auto data_sink_node = get_data_sink(ra_node);
  if (auto join = dynamic_cast<const RelJoin*>(data_sink_node)) {
    CHECK_EQ(join->inputCount(), 2u);
    const auto condition = join->getCondition();
    RexUsedInputsVisitor visitor;
    auto condition_inputs = visitor.visit(condition);
    std::vector<std::shared_ptr<RexInput>> condition_inputs_owned(
        visitor.get_inputs_owned());
    return std::make_pair(condition_inputs, condition_inputs_owned);
  }

  if (auto left_deep_join = dynamic_cast<const RelLeftDeepInnerJoin*>(data_sink_node)) {
    CHECK_GE(left_deep_join->inputCount(), 2u);
    const auto condition = left_deep_join->getInnerCondition();
    RexUsedInputsVisitor visitor;
    auto result = visitor.visit(condition);
    for (size_t nesting_level = 1; nesting_level <= left_deep_join->inputCount() - 1;
         ++nesting_level) {
      const auto outer_condition = left_deep_join->getOuterCondition(nesting_level);
      if (outer_condition) {
        const auto outer_result = visitor.visit(outer_condition);
        result.insert(outer_result.begin(), outer_result.end());
      }
    }
    std::vector<std::shared_ptr<RexInput>> used_inputs_owned(visitor.get_inputs_owned());
    return std::make_pair(result, used_inputs_owned);
  }

  if (dynamic_cast<const RelLogicalUnion*>(ra_node)) {
    CHECK_GT(ra_node->inputCount(), 1u)
        << ra_node->toString(RelRexToStringConfig::defaults());
  } else if (dynamic_cast<const RelTableFunction*>(ra_node)) {
    // no-op
    CHECK_GE(ra_node->inputCount(), 0u)
        << ra_node->toString(RelRexToStringConfig::defaults());
  } else {
    CHECK_EQ(ra_node->inputCount(), 1u)
        << ra_node->toString(RelRexToStringConfig::defaults());
  }
  return std::make_pair(std::unordered_set<const RexInput*>{},
                        std::vector<std::shared_ptr<RexInput>>{});
}

Here is the call graph for this function:

Here is the caller graph for this function:

JoinType anonymous_namespace{RelAlgExecutor.cpp}::get_join_type

(

const RelAlgNode *

ra

)

Definition at line 4303 of file RelAlgExecutor.cpp.

References get_data_sink(), INNER, INVALID, and join().

Referenced by RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), and RelAlgExecutor::getRelAlgTranslator().

                                             {
  auto sink = get_data_sink(ra);
  if (auto join = dynamic_cast<const RelJoin*>(sink)) {
    return join->getJoinType();
  }
  if (dynamic_cast<const RelLeftDeepInnerJoin*>(sink)) {
    return JoinType::INNER;
  }

  return JoinType::INVALID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<size_t> anonymous_namespace{RelAlgExecutor.cpp}::get_left_deep_join_input_sizes

(

const RelLeftDeepInnerJoin *

left_deep_join

)

Definition at line 4436 of file RelAlgExecutor.cpp.

References get_node_output(), RelAlgNode::getInput(), and RelAlgNode::inputCount().

Referenced by RelAlgExecutor::createCompoundWorkUnit(), and RelAlgExecutor::createProjectWorkUnit().

                                                {
  std::vector<size_t> input_sizes;
  for (size_t i = 0; i < left_deep_join->inputCount(); ++i) {
    const auto inputs = get_node_output(left_deep_join->getInput(i));
    input_sizes.push_back(inputs.size());
  }
  return input_sizes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::get_limit_value

(

std::optional< size_t >

limit

)

Definition at line 3198 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeSort(), and get_scan_limit().

                                                  {
  return limit ? *limit : 0;
}

Here is the caller graph for this function:

SQLTypeInfo anonymous_namespace{RelAlgExecutor.cpp}::get_logical_type_for_expr ( const Analyzer::Expr &  expr )

inline

Definition at line 1963 of file RelAlgExecutor.cpp.

References get_logical_type_info(), get_nullable_logical_type_info(), Analyzer::Expr::get_type_info(), is_agg(), is_count_distinct(), and kBIGINT.

Referenced by get_targets_meta().

                                                                       {
  if (is_count_distinct(&expr)) {
    return SQLTypeInfo(kBIGINT, false);
  } else if (is_agg(&expr)) {
    return get_nullable_logical_type_info(expr.get_type_info());
  }
  return get_logical_type_info(expr.get_type_info());
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unordered_set<PhysicalInput> anonymous_namespace{RelAlgExecutor.cpp}::get_physical_inputs_with_spi_col_id

(

const RelAlgNode *

ra

)

Definition at line 75 of file RelAlgExecutor.cpp.

References CHECK, get_physical_inputs(), Catalog_Namespace::SysCatalog::getCatalog(), Catalog_Namespace::SysCatalog::instance(), and PhysicalInput::table_id.

Referenced by RelAlgExecutor::computeColRangesCache(), RelAlgExecutor::computeStringDictionaryGenerations(), and RelAlgExecutor::setupCaching().

                          {
  const auto phys_inputs = get_physical_inputs(ra);
  std::unordered_set<PhysicalInput> phys_inputs2;
  for (auto& phi : phys_inputs) {
    const auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(phi.db_id);
    CHECK(catalog);
    phys_inputs2.insert(PhysicalInput{
        catalog->getColumnIdBySpi(phi.table_id, phi.col_id), phi.table_id, phi.db_id});
  }
  return phys_inputs2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<Analyzer::Expr*> anonymous_namespace{RelAlgExecutor.cpp}::get_raw_pointers

(

std::vector< std::shared_ptr< Analyzer::Expr >> const &

input

)

Definition at line 4784 of file RelAlgExecutor.cpp.

References shared::transform().

Referenced by RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createTableFunctionWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), and get_inputs_meta().

                                                         {
  std::vector<Analyzer::Expr*> output(input.size());
  auto const raw_ptr = [](auto& shared_ptr) { return shared_ptr.get(); };
  std::transform(input.cbegin(), input.cend(), output.begin(), raw_ptr);
  return output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size

(

const RelCompound *

compound

)

Definition at line 1690 of file RelAlgExecutor.cpp.

References RelCompound::getScalarSourcesSize().

Referenced by translate_scalar_sources(), and translate_scalar_sources_for_update().

                                                            {
  return compound->getScalarSourcesSize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size

(

const RelProject *

project

)

Definition at line 1694 of file RelAlgExecutor.cpp.

References RelProject::size().

                                                          {
  return project->size();
}

Here is the call graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size

(

const RelTableFunction *

table_func

)

Definition at line 1698 of file RelAlgExecutor.cpp.

References RelTableFunction::getTableFuncInputsSize().

                                                                   {
  return table_func->getTableFuncInputsSize();
}

Here is the call graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::get_scan_limit	(	const RelAlgNode *	ra,
		std::optional< size_t >	limit
	)

Definition at line 3202 of file RelAlgExecutor.cpp.

References get_limit_value().

Referenced by RelAlgExecutor::createSortInputWorkUnit().

                                                                       {
  const auto aggregate = dynamic_cast<const RelAggregate*>(ra);
  if (aggregate) {
    return 0;
  }
  const auto compound = dynamic_cast<const RelCompound*>(ra);
  return (compound && compound->isAggregate()) ? 0 : get_limit_value(limit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::vector<TargetMetaInfo> anonymous_namespace{RelAlgExecutor.cpp}::get_targets_meta	(	const RA *	ra_node,
		const std::vector< Analyzer::Expr * > &	target_exprs
	)

Definition at line 1973 of file RelAlgExecutor.cpp.

References CHECK, CHECK_EQ, and get_logical_type_for_expr().

Referenced by RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createTableFunctionWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), get_inputs_meta(), and get_targets_meta().

                                                  {
  std::vector<TargetMetaInfo> targets_meta;
  CHECK_EQ(ra_node->size(), target_exprs.size());
  for (size_t i = 0; i < ra_node->size(); ++i) {
    CHECK(target_exprs[i]);
    // TODO(alex): remove the count distinct type fixup.
    auto ti = get_logical_type_for_expr(*target_exprs[i]);
    targets_meta.emplace_back(
        ra_node->getFieldName(i), ti, target_exprs[i]->get_type_info());
  }
  return targets_meta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

std::vector<TargetMetaInfo> anonymous_namespace{RelAlgExecutor.cpp}::get_targets_meta	(	const RelFilter *	filter,
		const std::vector< Analyzer::Expr * > &	target_exprs
	)

Definition at line 1989 of file RelAlgExecutor.cpp.

References RelRexToStringConfig::defaults(), get_targets_meta(), RelAlgNode::getInput(), RelAlgNode::toString(), and UNREACHABLE.

                                                  {
  RelAlgNode const* input0 = filter->getInput(0);
  if (auto const* input = dynamic_cast<RelCompound const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  } else if (auto const* input = dynamic_cast<RelProject const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  } else if (auto const* input = dynamic_cast<RelLogicalUnion const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  } else if (auto const* input = dynamic_cast<RelAggregate const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  } else if (auto const* input = dynamic_cast<RelScan const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  } else if (auto const* input = dynamic_cast<RelLogicalValues const*>(input0)) {
    return get_targets_meta(input, target_exprs);
  }
  UNREACHABLE() << "Unhandled node type: "
                << input0->toString(RelRexToStringConfig::defaults());
  return {};
}

Here is the call graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelCompound *

compound

)

Definition at line 1408 of file RelAlgExecutor.cpp.

References anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor::get_inputs_owned(), RelCompound::getFilterExpr(), RelCompound::getScalarSource(), and RelCompound::getScalarSourcesSize().

Referenced by get_input_desc().

                                             {
  RexUsedInputsVisitor visitor;
  const auto filter_expr = compound->getFilterExpr();
  std::unordered_set<const RexInput*> used_inputs =
      filter_expr ? visitor.visit(filter_expr) : std::unordered_set<const RexInput*>{};
  const auto sources_size = compound->getScalarSourcesSize();
  for (size_t i = 0; i < sources_size; ++i) {
    const auto source_inputs = visitor.visit(compound->getScalarSource(i));
    used_inputs.insert(source_inputs.begin(), source_inputs.end());
  }
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned(visitor.get_inputs_owned());
  return std::make_pair(used_inputs, used_inputs_owned);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelAggregate *

aggregate

)

Definition at line 1423 of file RelAlgExecutor.cpp.

References CHECK_EQ, CHECK_GE, RelAggregate::getAggExprs(), RelAggregate::getGroupByCount(), RelAlgNode::getInput(), RelAlgNode::getOutputMetainfo(), and RelAlgNode::inputCount().

                                               {
  CHECK_EQ(size_t(1), aggregate->inputCount());
  std::unordered_set<const RexInput*> used_inputs;
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned;
  const auto source = aggregate->getInput(0);
  const auto& in_metainfo = source->getOutputMetainfo();
  const auto group_count = aggregate->getGroupByCount();
  CHECK_GE(in_metainfo.size(), group_count);
  for (size_t i = 0; i < group_count; ++i) {
    auto synthesized_used_input = new RexInput(source, i);
    used_inputs_owned.emplace_back(synthesized_used_input);
    used_inputs.insert(synthesized_used_input);
  }
  for (const auto& agg_expr : aggregate->getAggExprs()) {
    for (size_t i = 0; i < agg_expr->size(); ++i) {
      const auto operand_idx = agg_expr->getOperand(i);
      CHECK_GE(in_metainfo.size(), static_cast<size_t>(operand_idx));
      auto synthesized_used_input = new RexInput(source, operand_idx);
      used_inputs_owned.emplace_back(synthesized_used_input);
      used_inputs.insert(synthesized_used_input);
    }
  }
  return std::make_pair(used_inputs, used_inputs_owned);
}

Here is the call graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelProject *

project

)

Definition at line 1449 of file RelAlgExecutor.cpp.

References anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor::get_inputs_owned(), RelProject::getProjectAt(), and RelProject::size().

                                           {
  RexUsedInputsVisitor visitor;
  std::unordered_set<const RexInput*> used_inputs;
  for (size_t i = 0; i < project->size(); ++i) {
    const auto proj_inputs = visitor.visit(project->getProjectAt(i));
    used_inputs.insert(proj_inputs.begin(), proj_inputs.end());
  }
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned(visitor.get_inputs_owned());
  return std::make_pair(used_inputs, used_inputs_owned);
}

Here is the call graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelTableFunction *

table_func

)

Definition at line 1461 of file RelAlgExecutor.cpp.

References anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor::get_inputs_owned(), RelTableFunction::getTableFuncInputAt(), and RelTableFunction::getTableFuncInputsSize().

                                                    {
  RexUsedInputsVisitor visitor;
  std::unordered_set<const RexInput*> used_inputs;
  for (size_t i = 0; i < table_func->getTableFuncInputsSize(); ++i) {
    const auto table_func_inputs = visitor.visit(table_func->getTableFuncInputAt(i));
    used_inputs.insert(table_func_inputs.begin(), table_func_inputs.end());
  }
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned(visitor.get_inputs_owned());
  return std::make_pair(used_inputs, used_inputs_owned);
}

Here is the call graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelFilter *

filter

)

Definition at line 1473 of file RelAlgExecutor.cpp.

References CHECK, and get_data_sink().

                                         {
  std::unordered_set<const RexInput*> used_inputs;
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned;
  const auto data_sink_node = get_data_sink(filter);
  for (size_t nest_level = 0; nest_level < data_sink_node->inputCount(); ++nest_level) {
    const auto source = data_sink_node->getInput(nest_level);
    const auto scan_source = dynamic_cast<const RelScan*>(source);
    if (scan_source) {
      CHECK(source->getOutputMetainfo().empty());
      for (size_t i = 0; i < scan_source->size(); ++i) {
        auto synthesized_used_input = new RexInput(scan_source, i);
        used_inputs_owned.emplace_back(synthesized_used_input);
        used_inputs.insert(synthesized_used_input);
      }
    } else {
      const auto& partial_in_metadata = source->getOutputMetainfo();
      for (size_t i = 0; i < partial_in_metadata.size(); ++i) {
        auto synthesized_used_input = new RexInput(source, i);
        used_inputs_owned.emplace_back(synthesized_used_input);
        used_inputs.insert(synthesized_used_input);
      }
    }
  }
  return std::make_pair(used_inputs, used_inputs_owned);
}

Here is the call graph for this function:

std::pair<std::unordered_set<const RexInput*>, std::vector<std::shared_ptr<RexInput> > > anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs

(

const RelLogicalUnion *

logical_union

)

Definition at line 1500 of file RelAlgExecutor.cpp.

References RelAlgNode::getInput(), RelAlgNode::inputCount(), and VLOG.

                                                      {
  std::unordered_set<const RexInput*> used_inputs(logical_union->inputCount());
  std::vector<std::shared_ptr<RexInput>> used_inputs_owned;
  used_inputs_owned.reserve(logical_union->inputCount());
  VLOG(3) << "logical_union->inputCount()=" << logical_union->inputCount();
  auto const n_inputs = logical_union->inputCount();
  for (size_t nest_level = 0; nest_level < n_inputs; ++nest_level) {
    auto input = logical_union->getInput(nest_level);
    for (size_t i = 0; i < input->size(); ++i) {
      used_inputs_owned.emplace_back(std::make_shared<RexInput>(input, i));
      used_inputs.insert(used_inputs_owned.back().get());
    }
  }
  return std::make_pair(std::move(used_inputs), std::move(used_inputs_owned));
}

Here is the call graph for this function:

ErrorInfo anonymous_namespace{RelAlgExecutor.cpp}::getErrorDescription

(

const int32_t

error_code

)

Definition at line 4204 of file RelAlgExecutor.cpp.

References Executor::ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED, Executor::ERR_DIV_BY_ZERO, Executor::ERR_GEOS, Executor::ERR_INTERRUPTED, Executor::ERR_OUT_OF_CPU_MEM, Executor::ERR_OUT_OF_GPU_MEM, Executor::ERR_OUT_OF_RENDER_MEM, Executor::ERR_OUT_OF_TIME, Executor::ERR_OVERFLOW_OR_UNDERFLOW, Executor::ERR_SINGLE_VALUE_FOUND_MULTIPLE_VALUES, Executor::ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY, Executor::ERR_STRING_CONST_IN_RESULTSET, Executor::ERR_TOO_MANY_LITERALS, Executor::ERR_UNSUPPORTED_SELF_JOIN, and Executor::ERR_WIDTH_BUCKET_INVALID_ARGUMENT.

Referenced by RelAlgExecutor::getErrorMessageFromCode().

                                                        {
  // 'designated initializers' don't compile on Windows for std 17
  // They require /std:c++20.  They been removed for the windows port.
  switch (error_code) {
    case Executor::ERR_DIV_BY_ZERO:
      return {"ERR_DIV_BY_ZERO", "Division by zero"};
    case Executor::ERR_OUT_OF_GPU_MEM:
      return {"ERR_OUT_OF_GPU_MEM",

              "Query couldn't keep the entire working set of columns in GPU memory"};
    case Executor::ERR_UNSUPPORTED_SELF_JOIN:
      return {"ERR_UNSUPPORTED_SELF_JOIN", "Self joins not supported yet"};
    case Executor::ERR_OUT_OF_CPU_MEM:
      return {"ERR_OUT_OF_CPU_MEM", "Not enough host memory to execute the query"};
    case Executor::ERR_OVERFLOW_OR_UNDERFLOW:
      return {"ERR_OVERFLOW_OR_UNDERFLOW", "Overflow or underflow"};
    case Executor::ERR_OUT_OF_TIME:
      return {"ERR_OUT_OF_TIME", "Query execution has exceeded the time limit"};
    case Executor::ERR_INTERRUPTED:
      return {"ERR_INTERRUPTED", "Query execution has been interrupted"};
    case Executor::ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED:
      return {"ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED",
              "Columnar conversion not supported for variable length types"};
    case Executor::ERR_TOO_MANY_LITERALS:
      return {"ERR_TOO_MANY_LITERALS", "Too many literals in the query"};
    case Executor::ERR_STRING_CONST_IN_RESULTSET:
      return {"ERR_STRING_CONST_IN_RESULTSET",

              "NONE ENCODED String types are not supported as input result set."};
    case Executor::ERR_OUT_OF_RENDER_MEM:
      return {"ERR_OUT_OF_RENDER_MEM",

              "Insufficient GPU memory for query results in render output buffer "
              "sized by render-mem-bytes"};
    case Executor::ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY:
      return {"ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY",
              "Streaming-Top-N not supported in Render Query"};
    case Executor::ERR_SINGLE_VALUE_FOUND_MULTIPLE_VALUES:
      return {"ERR_SINGLE_VALUE_FOUND_MULTIPLE_VALUES",
              "Multiple distinct values encountered"};
    case Executor::ERR_GEOS:
      return {"ERR_GEOS", "ERR_GEOS"};
    case Executor::ERR_WIDTH_BUCKET_INVALID_ARGUMENT:
      return {"ERR_WIDTH_BUCKET_INVALID_ARGUMENT",

              "Arguments of WIDTH_BUCKET function does not satisfy the condition"};
    default:
      return {nullptr, nullptr};
  }
}

Here is the caller graph for this function:

size_t anonymous_namespace{RelAlgExecutor.cpp}::groups_approx_upper_bound

(

const std::vector< InputTableInfo > &

table_infos

)

Upper bound estimation for the number of groups. Not strictly correct and not tight, but if the tables involved are really small we shouldn't waste time doing the NDV estimation. We don't account for cross-joins and / or group by unnested array, which is the reason this estimation isn't entirely reliable.

Definition at line 3467 of file RelAlgExecutor.cpp.

References CHECK.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                               {
  CHECK(!table_infos.empty());
  const auto& first_table = table_infos.front();
  size_t max_num_groups = first_table.info.getNumTuplesUpperBound();
  for (const auto& table_info : table_infos) {
    if (table_info.info.getNumTuplesUpperBound() > max_num_groups) {
      max_num_groups = table_info.info.getNumTuplesUpperBound();
    }
  }
  return std::max(max_num_groups, size_t(1));
}

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::handle_query_hint	(	RegisteredQueryHint const &	query_hints,
		ExecutionOptions &	eo,
		CompilationOptions &	co
	)

Definition at line 1035 of file RelAlgExecutor.cpp.

References ExecutionOptions::allow_loop_joins, CPU, CompilationOptions::device_type, ExecutionOptions::dynamic_watchdog_time_limit, g_cluster, g_enable_data_recycler, g_use_query_resultset_cache, logger::INFO, RegisteredQueryHint::isHintRegistered(), kAllowLoopJoin, kColumnarOutput, kCpuMode, kCudaBlockSize, kCudaGridSize, kDisableLoopJoin, kDynamicWatchdog, kDynamicWatchdogOff, ExecutionOptions::keep_result, kKeepResult, kKeepTableFuncResult, kMaxJoinHashTableSize, kOptCudaBlockAndGridSizes, kQueryTimeLimit, kRowwiseOutput, kWatchdog, kWatchdogOff, LOG, ExecutionOptions::max_join_hash_table_size, RegisteredQueryHint::max_join_hash_table_size, ExecutionOptions::optimize_cuda_block_and_grid_sizes, ExecutionOptions::output_columnar_hint, RegisteredQueryHint::query_time_limit, VLOG, ExecutionOptions::with_dynamic_watchdog, and ExecutionOptions::with_watchdog.

                                               {
  auto columnar_output_hint_enabled = false;
  auto rowwise_output_hint_enabled = false;
  if (query_hints.isHintRegistered(QueryHint::kCpuMode)) {
    VLOG(1) << "A user forces to run the query on the CPU execution mode";
    co.device_type = ExecutorDeviceType::CPU;
  }
  if (query_hints.isHintRegistered(QueryHint::kKeepResult)) {
    if (!g_enable_data_recycler) {
      VLOG(1) << "A user enables keeping query resultset but is skipped since data "
                 "recycler is disabled";
    }
    if (!g_use_query_resultset_cache) {
      VLOG(1) << "A user enables keeping query resultset but is skipped since query "
                 "resultset recycler is disabled";
    } else {
      VLOG(1) << "A user enables keeping query resultset";
      eo.keep_result = true;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kKeepTableFuncResult)) {
    // we use this hint within the function 'executeTableFunction`
    if (!g_enable_data_recycler) {
      VLOG(1) << "A user enables keeping table function's resultset but is skipped "
                 "since data recycler is disabled";
    }
    if (!g_use_query_resultset_cache) {
      VLOG(1) << "A user enables keeping table function's resultset but is skipped "
                 "since query resultset recycler is disabled";
    } else {
      VLOG(1) << "A user enables keeping table function's resultset";
      eo.keep_result = true;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kWatchdog)) {
    if (!eo.with_watchdog) {
      VLOG(1) << "A user enables watchdog for this query";
      eo.with_watchdog = true;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kWatchdogOff)) {
    if (eo.with_watchdog) {
      VLOG(1) << "A user disables watchdog for this query";
      eo.with_watchdog = false;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kDynamicWatchdog)) {
    if (!eo.with_dynamic_watchdog) {
      VLOG(1) << "A user enables dynamic watchdog for this query";
      eo.with_watchdog = true;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kDynamicWatchdogOff)) {
    if (eo.with_dynamic_watchdog) {
      VLOG(1) << "A user disables dynamic watchdog for this query";
      eo.with_watchdog = false;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kQueryTimeLimit)) {
    std::ostringstream oss;
    oss << "A user sets query time limit to " << query_hints.query_time_limit << " ms";
    eo.dynamic_watchdog_time_limit = query_hints.query_time_limit;
    if (!eo.with_dynamic_watchdog) {
      eo.with_dynamic_watchdog = true;
      oss << " (and system automatically enables dynamic watchdog to activate the "
             "given \"query_time_limit\" hint)";
    }
    VLOG(1) << oss.str();
  }
  if (query_hints.isHintRegistered(QueryHint::kAllowLoopJoin)) {
    VLOG(1) << "A user enables loop join";
    eo.allow_loop_joins = true;
  }
  if (query_hints.isHintRegistered(QueryHint::kDisableLoopJoin)) {
    VLOG(1) << "A user disables loop join";
    eo.allow_loop_joins = false;
  }
  if (query_hints.isHintRegistered(QueryHint::kMaxJoinHashTableSize)) {
    eo.max_join_hash_table_size = query_hints.max_join_hash_table_size;
    VLOG(1) << "A user forces the maximum size of a join hash table as "
            << eo.max_join_hash_table_size << " bytes";
  }
  if (query_hints.isHintRegistered(QueryHint::kOptCudaBlockAndGridSizes)) {
    if (query_hints.isHintRegistered(QueryHint::kCudaGridSize) ||
        query_hints.isHintRegistered(QueryHint::kCudaBlockSize)) {
      VLOG(1) << "Skip query hint \"opt_cuda_grid_and_block_size\" when at least one "
                 "of the following query hints are given simultaneously: "
                 "\"cuda_block_size\" and \"cuda_grid_size_multiplier\"";
    } else {
      VLOG(1) << "A user enables optimization of cuda block and grid sizes";
      eo.optimize_cuda_block_and_grid_sizes = true;
    }
  }
  if (query_hints.isHintRegistered(QueryHint::kColumnarOutput)) {
    VLOG(1) << "A user forces the query to run with columnar output";
    columnar_output_hint_enabled = true;
  } else if (query_hints.isHintRegistered(QueryHint::kRowwiseOutput)) {
    VLOG(1) << "A user forces the query to run with rowwise output";
    rowwise_output_hint_enabled = true;
  }
  auto columnar_output_enabled = eo.output_columnar_hint ? !rowwise_output_hint_enabled
                                                         : columnar_output_hint_enabled;
  if (g_cluster && (columnar_output_hint_enabled || rowwise_output_hint_enabled)) {
    LOG(INFO) << "Currently, we do not support applying query hint to change query "
                 "output layout in distributed mode.";
  }
  eo.output_columnar_hint = columnar_output_enabled;
}

Here is the call graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::has_valid_query_plan_dag

(

const RelAlgNode *

node

)

Definition at line 219 of file RelAlgExecutor.cpp.

References EMPTY_HASHED_PLAN_DAG_KEY, and RelAlgNode::getQueryPlanDagHash().

Referenced by RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::executeRelAlgStep(), RelAlgExecutor::executeSort(), and RelAlgExecutor::executeTableFunction().

                                                      {
  return node->getQueryPlanDagHash() != EMPTY_HASHED_PLAN_DAG_KEY;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

int64_t anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str	(	T *	col_data,
		const std::string &	columnName,
		const SQLTypeInfo &	columnType,
		const Analyzer::Constant *	col_cv,
		const Catalog_Namespace::Catalog &	catalog
	)

Definition at line 2794 of file RelAlgExecutor.cpp.

References CHECK, logger::ERROR, SQLTypeInfo::get_comp_param(), Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), Catalog_Namespace::Catalog::getMetadataForDict(), inline_fixed_encoding_null_val(), LOG, Datum::stringval, and heavydb.dtypes::T.

Referenced by RelAlgExecutor::executeSimpleInsert(), and insert_one_dict_str().

                                                                     {
  if (col_cv->get_is_null()) {
    *col_data = inline_fixed_encoding_null_val(columnType);
  } else {
    const int dict_id = columnType.get_comp_param();
    const auto col_datum = col_cv->get_constval();
    const auto& str = *col_datum.stringval;
    const auto dd = catalog.getMetadataForDict(dict_id);
    CHECK(dd && dd->stringDict);
    int32_t str_id = dd->stringDict->getOrAdd(str);
    if (!dd->dictIsTemp) {
      const auto checkpoint_ok = dd->stringDict->checkpoint();
      if (!checkpoint_ok) {
        throw std::runtime_error("Failed to checkpoint dictionary for column " +
                                 columnName);
      }
    }
    const bool invalid = str_id > max_valid_int_value<T>();
    if (invalid || str_id == inline_int_null_value<int32_t>()) {
      if (invalid) {
        LOG(ERROR) << "Could not encode string: " << str
                   << ", the encoded value doesn't fit in " << sizeof(T) * 8
                   << " bits. Will store NULL instead.";
      }
      str_id = inline_fixed_encoding_null_val(columnType);
    }
    *col_data = str_id;
  }
  return *col_data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

int64_t anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str	(	T *	col_data,
		const ColumnDescriptor *	cd,
		const Analyzer::Constant *	col_cv,
		const Catalog_Namespace::Catalog &	catalog
	)

Definition at line 2830 of file RelAlgExecutor.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, and insert_one_dict_str().

                                                                     {
  return insert_one_dict_str(col_data, cd->columnName, cd->columnType, col_cv, catalog);
}

Here is the call graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::is_agg

(

const Analyzer::Expr *

expr

)

Definition at line 1950 of file RelAlgExecutor.cpp.

References Analyzer::AggExpr::get_aggtype(), kAVG, kMAX, kMIN, kSUM, and kSUM_IF.

Referenced by anonymous_namespace{RelAlgDag.cpp}::create_compound(), RelAlgExecutor::executeWorkUnit(), get_logical_type_for_expr(), and ResultSet::getSingleSlotTargetBitmap().

                                      {
  const auto agg_expr = dynamic_cast<const Analyzer::AggExpr*>(expr);
  if (agg_expr && agg_expr->get_contains_agg()) {
    auto agg_type = agg_expr->get_aggtype();
    if (agg_type == SQLAgg::kMIN || agg_type == SQLAgg::kMAX ||
        agg_type == SQLAgg::kSUM || agg_type == SQLAgg::kSUM_IF ||
        agg_type == SQLAgg::kAVG) {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::is_count_distinct

(

const Analyzer::Expr *

expr

)

Definition at line 1945 of file RelAlgExecutor.cpp.

References Analyzer::AggExpr::get_is_distinct().

Referenced by get_logical_type_for_expr().

                                                 {
  const auto agg_expr = dynamic_cast<const Analyzer::AggExpr*>(expr);
  return agg_expr && agg_expr->get_is_distinct();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::is_projection

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 3479 of file RelAlgExecutor.cpp.

References RelAlgExecutionUnit::groupby_exprs.

Referenced by can_output_columnar(), and RelAlgTranslator::translateGeoFunctionArg().

                                                           {
  return ra_exe_unit.groupby_exprs.size() == 1 && !ra_exe_unit.groupby_exprs.front();
}

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::is_window_execution_unit

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 2312 of file RelAlgExecutor.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), and RelAlgExecutionUnit::target_exprs.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                      {
  return std::any_of(ra_exe_unit.target_exprs.begin(),
                     ra_exe_unit.target_exprs.end(),
                     [](const Analyzer::Expr* expr) {
                       return dynamic_cast<const Analyzer::WindowFunction*>(expr);
                     });
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<JoinType> anonymous_namespace{RelAlgExecutor.cpp}::left_deep_join_types

(

const RelLeftDeepInnerJoin *

left_deep_join

)

Definition at line 4383 of file RelAlgExecutor.cpp.

References ANTI, CHECK_GE, RelLeftDeepInnerJoin::getJoinType(), RelLeftDeepInnerJoin::getOuterCondition(), INNER, RelAlgNode::inputCount(), LEFT, and SEMI.

Referenced by RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::getRelAlgTranslator(), and RelAlgExecutor::translateLeftDeepJoinFilter().

                                                                                     {
  CHECK_GE(left_deep_join->inputCount(), size_t(2));
  std::vector<JoinType> join_types(left_deep_join->inputCount() - 1, JoinType::INNER);
  for (size_t nesting_level = 1; nesting_level <= left_deep_join->inputCount() - 1;
       ++nesting_level) {
    if (left_deep_join->getOuterCondition(nesting_level)) {
      join_types[nesting_level - 1] = JoinType::LEFT;
    }
    auto cur_level_join_type = left_deep_join->getJoinType(nesting_level);
    if (cur_level_join_type == JoinType::SEMI || cur_level_join_type == JoinType::ANTI) {
      join_types[nesting_level - 1] = cur_level_join_type;
    }
  }
  return join_types;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class QualsList >

bool anonymous_namespace{RelAlgExecutor.cpp}::list_contains_expression	(	const QualsList &	haystack,
		const std::shared_ptr< Analyzer::Expr > &	needle
	)

Definition at line 4621 of file RelAlgExecutor.cpp.

Referenced by reverse_logical_distribution().

                                                                         {
  for (const auto& qual : haystack) {
    if (*qual == *needle) {
      return true;
    }
  }
  return false;
}

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::node_is_aggregate

(

const RelAlgNode *

ra

)

Definition at line 69 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeRelAlgQuerySingleStep(), and RelAlgExecutor::executeSort().

                                             {
  const auto compound = dynamic_cast<const RelCompound*>(ra);
  const auto aggregate = dynamic_cast<const RelAggregate*>(ra);
  return ((compound && compound->isAggregate()) || aggregate);
}

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::prepare_for_system_table_execution	(	const RelAlgNode &	ra_node,
		const CompilationOptions &	co
	)

Definition at line 154 of file RelAlgExecutor.cpp.

References CHECK, CHECK_LE, CPU, Data_Namespace::CPU_LEVEL, CompilationOptions::device_type, g_enable_system_tables, get_physical_inputs(), Catalog_Namespace::SysCatalog::getCatalog(), Chunk_NS::Chunk::getChunk(), Catalog_Namespace::SysCatalog::instance(), and shared::kInfoSchemaDbName.

Referenced by RelAlgExecutor::executeRelAlgQueryNoRetry(), and RelAlgExecutor::prepareForSystemTableExecution().

                                                                      {
  if (g_enable_system_tables) {
    const auto info_schema_catalog =
        Catalog_Namespace::SysCatalog::instance().getCatalog(shared::kInfoSchemaDbName);
    CHECK(info_schema_catalog);
    std::map<int32_t, std::vector<int32_t>> system_table_columns_by_table_id;
    for (const auto& physical_input : get_physical_inputs(&ra_node)) {
      if (info_schema_catalog->getDatabaseId() != physical_input.db_id) {
        continue;
      }
      const auto table_id = physical_input.table_id;
      const auto table = info_schema_catalog->getMetadataForTable(table_id, false);
      CHECK(table);
      if (table->is_in_memory_system_table) {
        const auto column_id =
            info_schema_catalog->getColumnIdBySpi(table_id, physical_input.col_id);
        system_table_columns_by_table_id[table_id].emplace_back(column_id);
      }
    }
    // Execute on CPU for queries involving system tables
    if (!system_table_columns_by_table_id.empty() &&
        co.device_type != ExecutorDeviceType::CPU) {
      throw QueryMustRunOnCpu();
    }

    for (const auto& [table_id, column_ids] : system_table_columns_by_table_id) {
      // Clear any previously cached data, since system tables depend on point in
      // time data snapshots.
      info_schema_catalog->getDataMgr().deleteChunksWithPrefix(
          ChunkKey{info_schema_catalog->getDatabaseId(), table_id},
          Data_Namespace::CPU_LEVEL);

      // TODO(Misiu): This prefetching can be removed if we can add support for
      // ExpressionRanges to reduce invalid with valid ranges (right now prefetching
      // causes us to fetch the chunks twice).  Right now if we do not prefetch (i.e. if
      // we remove the code below) some nodes will return valid ranges and others will
      // return unknown because they only use placeholder metadata and the LeafAggregator
      // has no idea how to reduce the two.
      const auto td = info_schema_catalog->getMetadataForTable(table_id);
      CHECK(td);
      CHECK(td->fragmenter);
      auto fragment_count = td->fragmenter->getFragmentsForQuery().fragments.size();
      CHECK_LE(fragment_count, static_cast<size_t>(1))
          << "In-memory system tables are expected to have a single fragment.";
      if (fragment_count > 0) {
        for (auto column_id : column_ids) {
          // Prefetch system table chunks in order to force chunk statistics metadata
          // computation.
          const auto cd = info_schema_catalog->getMetadataForColumn(table_id, column_id);
          const ChunkKey chunk_key{
              info_schema_catalog->getDatabaseId(), table_id, column_id, 0};
          Chunk_NS::Chunk::getChunk(cd,
                                    &(info_schema_catalog->getDataMgr()),
                                    chunk_key,
                                    Data_Namespace::CPU_LEVEL,
                                    0,
                                    0,
                                    0);
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::prepare_foreign_table_for_execution

(

const RelAlgNode &

ra_node

)

Definition at line 146 of file RelAlgExecutor.cpp.

References anonymous_namespace{Execute.cpp}::prepare_string_dictionaries(), and set_parallelism_hints().

Referenced by RelAlgExecutor::executeRelAlgQueryNoRetry(), and RelAlgExecutor::prepareForeignTables().

                                                                    {
  // Iterate through ra_node inputs for types that need to be loaded pre-execution
  // If they do not have valid metadata, load them into CPU memory to generate
  // the metadata and leave them ready to be used by the query
  set_parallelism_hints(ra_node);
  prepare_string_dictionaries(ra_node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::prepare_string_dictionaries

(

const RelAlgNode &

ra_node

)

Definition at line 134 of file RelAlgExecutor.cpp.

References CHECK, StorageType::FOREIGN_TABLE, get_physical_inputs(), Catalog_Namespace::SysCatalog::getCatalog(), Catalog_Namespace::SysCatalog::instance(), and foreign_storage::populate_string_dictionary().

                                                            {
  for (const auto [col_id, table_id, db_id] : get_physical_inputs(&ra_node)) {
    const auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
    CHECK(catalog);
    const auto table = catalog->getMetadataForTable(table_id, false);
    if (table && table->storageType == StorageType::FOREIGN_TABLE) {
      const auto spi_col_id = catalog->getColumnIdBySpi(table_id, col_id);
      foreign_storage::populate_string_dictionary(table_id, spi_col_id, db_id);
    }
  }
}

Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgExecutor.cpp}::reverse_logical_distribution

(

const std::shared_ptr< Analyzer::Expr > &

expr

)

Definition at line 4634 of file RelAlgExecutor.cpp.

References build_logical_expression(), CHECK_GE, kAND, kONE, kOR, list_contains_expression(), Parser::OperExpr::normalize(), qual_to_conjunctive_form(), and qual_to_disjunctive_form().

Referenced by RelAlgExecutor::makeJoinQuals().

                                             {
  const auto expr_terms = qual_to_disjunctive_form(expr);
  CHECK_GE(expr_terms.size(), size_t(1));
  const auto& first_term = expr_terms.front();
  const auto first_term_factors = qual_to_conjunctive_form(first_term);
  std::vector<std::shared_ptr<Analyzer::Expr>> common_factors;
  // First, collect the conjunctive components common to all the disjunctive components.
  // Don't do it for simple qualifiers, we only care about expensive or join qualifiers.
  for (const auto& first_term_factor : first_term_factors.quals) {
    bool is_common =
        expr_terms.size() > 1;  // Only report common factors for disjunction.
    for (size_t i = 1; i < expr_terms.size(); ++i) {
      const auto crt_term_factors = qual_to_conjunctive_form(expr_terms[i]);
      if (!list_contains_expression(crt_term_factors.quals, first_term_factor)) {
        is_common = false;
        break;
      }
    }
    if (is_common) {
      common_factors.push_back(first_term_factor);
    }
  }
  if (common_factors.empty()) {
    return expr;
  }
  // Now that the common expressions are known, collect the remaining expressions.
  std::vector<std::shared_ptr<Analyzer::Expr>> remaining_terms;
  for (const auto& term : expr_terms) {
    const auto term_cf = qual_to_conjunctive_form(term);
    std::vector<std::shared_ptr<Analyzer::Expr>> remaining_quals(
        term_cf.simple_quals.begin(), term_cf.simple_quals.end());
    for (const auto& qual : term_cf.quals) {
      if (!list_contains_expression(common_factors, qual)) {
        remaining_quals.push_back(qual);
      }
    }
    if (!remaining_quals.empty()) {
      remaining_terms.push_back(build_logical_expression(remaining_quals, kAND));
    }
  }
  // Reconstruct the expression with the transformation applied.
  const auto common_expr = build_logical_expression(common_factors, kAND);
  if (remaining_terms.empty()) {
    return common_expr;
  }
  const auto remaining_expr = build_logical_expression(remaining_terms, kOR);
  return Parser::OperExpr::normalize(kAND, kONE, common_expr, remaining_expr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::rewrite_quals

(

const std::list< std::shared_ptr< Analyzer::Expr >> &

quals

)

Definition at line 4446 of file RelAlgExecutor.cpp.

References rewrite_expr().

Referenced by RelAlgExecutor::createCompoundWorkUnit().

                                                       {
  std::list<std::shared_ptr<Analyzer::Expr>> rewritten_quals;
  for (const auto& qual : quals) {
    const auto rewritten_qual = rewrite_expr(qual.get());
    rewritten_quals.push_back(rewritten_qual ? rewritten_qual : qual);
  }
  return rewritten_quals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<const RexScalar*> anonymous_namespace{RelAlgExecutor.cpp}::rex_to_conjunctive_form

(

const RexScalar *

qual_expr

)

Definition at line 4594 of file RelAlgExecutor.cpp.

References CHECK, CHECK_GE, and kAND.

Referenced by RelAlgExecutor::makeJoinQuals().

                                                                                {
  CHECK(qual_expr);
  const auto bin_oper = dynamic_cast<const RexOperator*>(qual_expr);
  if (!bin_oper || bin_oper->getOperator() != kAND) {
    return {qual_expr};
  }
  CHECK_GE(bin_oper->size(), size_t(2));
  auto lhs_cf = rex_to_conjunctive_form(bin_oper->getOperand(0));
  for (size_t i = 1; i < bin_oper->size(); ++i) {
    const auto rhs_cf = rex_to_conjunctive_form(bin_oper->getOperand(i));
    lhs_cf.insert(lhs_cf.end(), rhs_cf.begin(), rhs_cf.end());
  }
  return lhs_cf;
}

Here is the caller graph for this function:

const RexScalar* anonymous_namespace{RelAlgExecutor.cpp}::scalar_at	(	const size_t	i,
		const RelCompound *	compound
	)

Definition at line 1702 of file RelAlgExecutor.cpp.

References RelCompound::getScalarSource().

Referenced by translate_scalar_sources(), and translate_scalar_sources_for_update().

                                                                        {
  return compound->getScalarSource(i);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const RexScalar* anonymous_namespace{RelAlgExecutor.cpp}::scalar_at	(	const size_t	i,
		const RelProject *	project
	)

Definition at line 1706 of file RelAlgExecutor.cpp.

References RelProject::getProjectAt().

                                                                      {
  return project->getProjectAt(i);
}

Here is the call graph for this function:

const RexScalar* anonymous_namespace{RelAlgExecutor.cpp}::scalar_at	(	const size_t	i,
		const RelTableFunction *	table_func
	)

Definition at line 1710 of file RelAlgExecutor.cpp.

References RelTableFunction::getTableFuncInputAt().

                                                                               {
  return table_func->getTableFuncInputAt(i);
}

Here is the call graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::set_parallelism_hints

(

const RelAlgNode &

ra_node

)

Definition at line 88 of file RelAlgExecutor.cpp.

References CHECK, Data_Namespace::CPU_LEVEL, StorageType::FOREIGN_TABLE, get_physical_inputs(), Catalog_Namespace::SysCatalog::getCatalog(), Catalog_Namespace::SysCatalog::getDataMgr(), PersistentStorageMgr::getForeignStorageMgr(), Data_Namespace::DataMgr::getPersistentStorageMgr(), Catalog_Namespace::SysCatalog::instance(), and foreign_storage::key_does_not_shard_to_leaf().

Referenced by prepare_foreign_table_for_execution().

                                                      {
  std::map<ChunkKey, std::set<foreign_storage::ForeignStorageMgr::ParallelismHint>>
      parallelism_hints_per_table;
  for (const auto& physical_input : get_physical_inputs(&ra_node)) {
    const auto table_id = physical_input.table_id;
    const auto catalog =
        Catalog_Namespace::SysCatalog::instance().getCatalog(physical_input.db_id);
    CHECK(catalog);
    const auto table = catalog->getMetadataForTable(table_id, true);
    if (table && table->storageType == StorageType::FOREIGN_TABLE &&
        !table->is_in_memory_system_table) {
      const auto col_id = catalog->getColumnIdBySpi(table_id, physical_input.col_id);
      const auto col_desc = catalog->getMetadataForColumn(table_id, col_id);
      const auto foreign_table = catalog->getForeignTable(table_id);
      for (const auto& fragment :
           foreign_table->fragmenter->getFragmentsForQuery().fragments) {
        Chunk_NS::Chunk chunk{col_desc};
        ChunkKey chunk_key = {
            physical_input.db_id, table_id, col_id, fragment.fragmentId};

        // Parallelism hints should not include fragments that are not mapped to the
        // current node, otherwise we will try to prefetch them and run into trouble.
        if (foreign_storage::key_does_not_shard_to_leaf(chunk_key)) {
          continue;
        }

        // do not include chunk hints that are in CPU memory
        if (!chunk.isChunkOnDevice(
                &catalog->getDataMgr(), chunk_key, Data_Namespace::CPU_LEVEL, 0)) {
          parallelism_hints_per_table[{physical_input.db_id, table_id}].insert(
              foreign_storage::ForeignStorageMgr::ParallelismHint{col_id,
                                                                  fragment.fragmentId});
        }
      }
    }
  }
  if (!parallelism_hints_per_table.empty()) {
    auto foreign_storage_mgr = Catalog_Namespace::SysCatalog::instance()
                                   .getDataMgr()
                                   .getPersistentStorageMgr()
                                   ->getForeignStorageMgr();
    CHECK(foreign_storage_mgr);
    foreign_storage_mgr->setParallelismHints(parallelism_hints_per_table);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict

(

const std::shared_ptr< Analyzer::Expr >

expr

)

Definition at line 1714 of file RelAlgExecutor.cpp.

References kENCODING_DICT, kENCODING_NONE, shared::StringDictKey::kTransientDictKey, and TRANSIENT_DICT_ID.

Referenced by set_transient_dict_maybe(), translate_groupby_exprs(), and translate_targets().

                                            {
  const auto& ti = expr->get_type_info();
  if (!ti.is_string() || ti.get_compression() != kENCODING_NONE) {
    return expr;
  }
  auto transient_dict_ti = ti;
  transient_dict_ti.set_compression(kENCODING_DICT);
  transient_dict_ti.set_comp_param(TRANSIENT_DICT_ID);
  transient_dict_ti.setStringDictKey(shared::StringDictKey::kTransientDictKey);
  transient_dict_ti.set_fixed_size();
  return expr->add_cast(transient_dict_ti);
}

Here is the caller graph for this function:

void anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict_maybe	(	std::vector< std::shared_ptr< Analyzer::Expr >> &	scalar_sources,
		const std::shared_ptr< Analyzer::Expr > &	expr
	)

Definition at line 1728 of file RelAlgExecutor.cpp.

References fold_expr(), and set_transient_dict().

Referenced by translate_scalar_sources(), and translate_scalar_sources_for_update().

                                             {
  try {
    scalar_sources.push_back(set_transient_dict(fold_expr(expr.get())));
  } catch (...) {
    scalar_sources.push_back(fold_expr(expr.get()));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgExecutor.cpp}::should_output_columnar

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 3523 of file RelAlgExecutor.cpp.

References g_columnar_large_projections, g_columnar_large_projections_threshold, RelAlgExecutionUnit::scan_limit, and RelAlgExecutionUnit::target_exprs.

Referenced by RelAlgExecutor::executeWorkUnit().

                                                                    {
  for (const auto& target_expr : ra_exe_unit.target_exprs) {
    if (target_expr->get_type_info().usesFlatBuffer()) {
      // using FlatBuffer memory layout implies columnar-only output
      return true;
    }
  }
  return g_columnar_large_projections &&
         ra_exe_unit.scan_limit >= g_columnar_large_projections_threshold;
}

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::synthesize_inputs	(	const RelAlgNode *	ra_node,
		const size_t	nest_level,
		const std::vector< TargetMetaInfo > &	in_metainfo,
		const std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level
	)

Definition at line 4759 of file RelAlgExecutor.cpp.

References CHECK, CHECK_GE, CHECK_LE, RelAlgNode::getInput(), RelAlgNode::inputCount(), and table_key_from_ra().

Referenced by RelAlgExecutor::createAggregateWorkUnit(), and get_inputs_meta().

                                                                         {
  CHECK_LE(size_t(1), ra_node->inputCount());
  CHECK_GE(size_t(2), ra_node->inputCount());
  const auto input = ra_node->getInput(nest_level);
  const auto it_rte_idx = input_to_nest_level.find(input);
  CHECK(it_rte_idx != input_to_nest_level.end());
  const int rte_idx = it_rte_idx->second;
  const auto table_key = table_key_from_ra(input);
  std::vector<std::shared_ptr<Analyzer::Expr>> inputs;
  const auto scan_ra = dynamic_cast<const RelScan*>(input);
  int input_idx = 0;
  for (const auto& input_meta : in_metainfo) {
    inputs.push_back(std::make_shared<Analyzer::ColumnVar>(
        input_meta.get_type_info(),
        shared::ColumnKey{table_key, scan_ra ? input_idx + 1 : input_idx},
        rte_idx));
    ++input_idx;
  }
  return inputs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

shared::TableKey anonymous_namespace{RelAlgExecutor.cpp}::table_key_from_ra

(

const RelAlgNode *

ra_node

)

Definition at line 1516 of file RelAlgExecutor.cpp.

References CHECK, shared::TableKey::db_id, and RelAlgNode::getId().

Referenced by collect_used_input_desc(), get_input_desc_impl(), and synthesize_inputs().

                                                            {
  const auto scan_ra = dynamic_cast<const RelScan*>(ra_node);
  shared::TableKey table_key{0, int32_t(-ra_node->getId())};
  if (scan_ra) {
    table_key.db_id = scan_ra->getCatalog().getDatabaseId();
    const auto td = scan_ra->getTableDescriptor();
    CHECK(td);
    table_key.table_id = td->tableId;
  }
  return table_key;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::target_exprs_for_union

(

RelAlgNode const *

input_node

)

Definition at line 4972 of file RelAlgExecutor.cpp.

References RelAlgNode::getId(), RelAlgNode::getOutputMetainfo(), shared::printContainer(), and VLOG.

Referenced by RelAlgExecutor::createUnionWorkUnit().

                                  {
  std::vector<TargetMetaInfo> const& tmis = input_node->getOutputMetainfo();
  VLOG(3) << "input_node->getOutputMetainfo()=" << shared::printContainer(tmis);
  const int negative_node_id = -input_node->getId();
  int32_t db_id{0};
  if (auto rel_scan = dynamic_cast<const RelScan*>(input_node)) {
    db_id = rel_scan->getCatalog().getDatabaseId();
  }
  std::vector<std::shared_ptr<Analyzer::Expr>> target_exprs;
  target_exprs.reserve(tmis.size());
  for (size_t i = 0; i < tmis.size(); ++i) {
    target_exprs.push_back(std::make_shared<Analyzer::ColumnVar>(
        tmis[i].get_type_info(),
        shared::ColumnKey{db_id, negative_node_id, int32_t(i)},
        0));
  }
  return target_exprs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgExecutor.cpp}::transform_to_inner

(

const Analyzer::Expr *

expr

)

Definition at line 2462 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::computeWindow().

                                                                         {
  const auto tuple = dynamic_cast<const Analyzer::ExpressionTuple*>(expr);
  if (tuple) {
    std::vector<std::shared_ptr<Analyzer::Expr>> transformed_tuple;
    for (const auto& element : tuple->getTuple()) {
      transformed_tuple.push_back(transform_to_inner(element.get()));
    }
    return makeExpr<Analyzer::ExpressionTuple>(transformed_tuple);
  }
  const auto col = dynamic_cast<const Analyzer::ColumnVar*>(expr);
  if (!col) {
    throw std::runtime_error("Only columns supported in the window partition for now");
  }
  return makeExpr<Analyzer::ColumnVar>(col->get_type_info(), col->getColumnKey(), 1);
}

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs	(	const RelCompound *	compound,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	scalar_sources
	)

Definition at line 1814 of file RelAlgExecutor.cpp.

References RelCompound::getGroupByCount(), RelCompound::isAggregate(), and set_transient_dict().

Referenced by RelAlgExecutor::createAggregateWorkUnit(), and RelAlgExecutor::createCompoundWorkUnit().

                                                                  {
  if (!compound->isAggregate()) {
    return {nullptr};
  }
  std::list<std::shared_ptr<Analyzer::Expr>> groupby_exprs;
  for (size_t group_idx = 0; group_idx < compound->getGroupByCount(); ++group_idx) {
    groupby_exprs.push_back(set_transient_dict(scalar_sources[group_idx]));
  }
  return groupby_exprs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs	(	const RelAggregate *	aggregate,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	scalar_sources
	)

Definition at line 1827 of file RelAlgExecutor.cpp.

References RelAggregate::getGroupByCount(), and set_transient_dict().

                                                                  {
  std::list<std::shared_ptr<Analyzer::Expr>> groupby_exprs;
  for (size_t group_idx = 0; group_idx < aggregate->getGroupByCount(); ++group_idx) {
    groupby_exprs.push_back(set_transient_dict(scalar_sources[group_idx]));
  }
  return groupby_exprs;
}

Here is the call graph for this function:

QualsConjunctiveForm anonymous_namespace{RelAlgExecutor.cpp}::translate_quals	(	const RelCompound *	compound,
		const RelAlgTranslator &	translator
	)

Definition at line 1837 of file RelAlgExecutor.cpp.

References fold_expr(), RelCompound::getFilterExpr(), qual_to_conjunctive_form(), and RelAlgTranslator::translate().

Referenced by RelAlgExecutor::createCompoundWorkUnit().

                                                                         {
  const auto filter_rex = compound->getFilterExpr();
  const auto filter_expr = filter_rex ? translator.translate(filter_rex) : nullptr;
  return filter_expr ? qual_to_conjunctive_form(fold_expr(filter_expr.get()))
                     : QualsConjunctiveForm{};
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::vector<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources	(	const RA *	ra_node,
		const RelAlgTranslator &	translator,
		const ::ExecutorType	executor_type
	)

Definition at line 1748 of file RelAlgExecutor.cpp.

References cast_dict_to_none(), RelRexToStringConfig::defaults(), fold_expr(), get_scalar_sources_size(), Native, rewrite_array_elements(), rewrite_expr(), scalar_at(), set_transient_dict_maybe(), TableFunctions, RelAlgTranslator::translate(), and VLOG.

Referenced by RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), and RelAlgExecutor::createTableFunctionWorkUnit().

                                      {
  std::vector<std::shared_ptr<Analyzer::Expr>> scalar_sources;
  const size_t scalar_sources_size = get_scalar_sources_size(ra_node);
  VLOG(3) << "get_scalar_sources_size("
          << ra_node->toString(RelRexToStringConfig::defaults())
          << ") = " << scalar_sources_size;
  for (size_t i = 0; i < scalar_sources_size; ++i) {
    const auto scalar_rex = scalar_at(i, ra_node);
    if (dynamic_cast<const RexRef*>(scalar_rex)) {
      // RexRef are synthetic scalars we append at the end of the real ones
      // for the sake of taking memory ownership, no real work needed here.
      continue;
    }

    const auto scalar_expr =
        rewrite_array_elements(translator.translate(scalar_rex).get());
    const auto rewritten_expr = rewrite_expr(scalar_expr.get());
    if (executor_type == ExecutorType::Native) {
      set_transient_dict_maybe(scalar_sources, rewritten_expr);
    } else if (executor_type == ExecutorType::TableFunctions) {
      scalar_sources.push_back(fold_expr(rewritten_expr.get()));
    } else {
      scalar_sources.push_back(cast_dict_to_none(fold_expr(rewritten_expr.get())));
    }
  }

  return scalar_sources;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class RA >

std::vector<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources_for_update	(	const RA *	ra_node,
		const RelAlgTranslator &	translator,
		int32_t	tableId,
		const Catalog_Namespace::Catalog &	cat,
		const ColumnNameList &	colNames,
		size_t	starting_projection_column_idx
	)

Definition at line 1781 of file RelAlgExecutor.cpp.

References cat(), get_scalar_sources_size(), rewrite_array_elements(), rewrite_expr(), scalar_at(), set_transient_dict_maybe(), and RelAlgTranslator::translate().

                                           {
  std::vector<std::shared_ptr<Analyzer::Expr>> scalar_sources;
  for (size_t i = 0; i < get_scalar_sources_size(ra_node); ++i) {
    const auto scalar_rex = scalar_at(i, ra_node);
    if (dynamic_cast<const RexRef*>(scalar_rex)) {
      // RexRef are synthetic scalars we append at the end of the real ones
      // for the sake of taking memory ownership, no real work needed here.
      continue;
    }

    std::shared_ptr<Analyzer::Expr> translated_expr;
    if (i >= starting_projection_column_idx && i < get_scalar_sources_size(ra_node) - 1) {
      translated_expr = cast_to_column_type(translator.translate(scalar_rex),
                                            tableId,
                                            cat,
                                            colNames[i - starting_projection_column_idx]);
    } else {
      translated_expr = translator.translate(scalar_rex);
    }
    const auto scalar_expr = rewrite_array_elements(translated_expr.get());
    const auto rewritten_expr = rewrite_expr(scalar_expr.get());
    set_transient_dict_maybe(scalar_sources, rewritten_expr);
  }

  return scalar_sources;
}

Here is the call graph for this function:

std::vector<Analyzer::Expr*> anonymous_namespace{RelAlgExecutor.cpp}::translate_targets	(	std::vector< std::shared_ptr< Analyzer::Expr >> &	target_exprs_owned,
		std::unordered_map< size_t, SQLTypeInfo > &	target_exprs_type_infos,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	scalar_sources,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	groupby_exprs,
		const RelCompound *	compound,
		const RelAlgTranslator &	translator,
		const ExecutorType	executor_type
	)

Definition at line 1868 of file RelAlgExecutor.cpp.

References cast_dict_to_none(), CHECK, CHECK_GE, CHECK_LE, anonymous_namespace{RelAlgExecutor.cpp}::anonymous_namespace{RelAlgExecutor.cpp}::conditionally_change_arg_to_int_type(), fold_expr(), RexRef::getIndex(), RelCompound::getTargetExpr(), Analyzer::Var::kGROUPBY, Native, rewrite_array_elements(), rewrite_expr(), set_transient_dict(), RelCompound::size(), RelAlgTranslator::translate(), RelAlgTranslator::translateAggregateRex(), and var_ref().

Referenced by RelAlgExecutor::createAggregateWorkUnit(), and RelAlgExecutor::createCompoundWorkUnit().

                                      {
  std::vector<Analyzer::Expr*> target_exprs;
  for (size_t i = 0; i < compound->size(); ++i) {
    const auto target_rex = compound->getTargetExpr(i);
    const auto target_rex_agg = dynamic_cast<const RexAgg*>(target_rex);
    std::shared_ptr<Analyzer::Expr> target_expr;
    if (target_rex_agg) {
      target_expr =
          RelAlgTranslator::translateAggregateRex(target_rex_agg, scalar_sources);
      conditionally_change_arg_to_int_type(i, target_expr, target_exprs_type_infos);
    } else {
      const auto target_rex_scalar = dynamic_cast<const RexScalar*>(target_rex);
      const auto target_rex_ref = dynamic_cast<const RexRef*>(target_rex_scalar);
      if (target_rex_ref) {
        const auto ref_idx = target_rex_ref->getIndex();
        CHECK_GE(ref_idx, size_t(1));
        CHECK_LE(ref_idx, groupby_exprs.size());
        const auto groupby_expr = *std::next(groupby_exprs.begin(), ref_idx - 1);
        target_expr = var_ref(groupby_expr.get(), Analyzer::Var::kGROUPBY, ref_idx);
      } else {
        target_expr =
            rewrite_array_elements(translator.translate(target_rex_scalar).get());
        auto rewritten_expr = rewrite_expr(target_expr.get());
        target_expr = fold_expr(rewritten_expr.get());
        if (executor_type == ExecutorType::Native) {
          try {
            target_expr = set_transient_dict(target_expr);
          } catch (...) {
            // noop
          }
        } else {
          target_expr = cast_dict_to_none(target_expr);
        }
      }
      target_exprs_type_infos.emplace(i, target_expr->get_type_info());
    }
    CHECK(target_expr);
    target_exprs_owned.push_back(target_expr);
    target_exprs.push_back(target_expr.get());
  }
  return target_exprs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<Analyzer::Expr*> anonymous_namespace{RelAlgExecutor.cpp}::translate_targets	(	std::vector< std::shared_ptr< Analyzer::Expr >> &	target_exprs_owned,
		std::unordered_map< size_t, SQLTypeInfo > &	target_exprs_type_infos,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	scalar_sources,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	groupby_exprs,
		const RelAggregate *	aggregate,
		const RelAlgTranslator &	translator
	)

Definition at line 1918 of file RelAlgExecutor.cpp.

References CHECK, fold_expr(), RelAggregate::getAggExprs(), Analyzer::Var::kGROUPBY, RelAlgTranslator::translateAggregateRex(), and var_ref().

                                        {
  std::vector<Analyzer::Expr*> target_exprs;
  size_t group_key_idx = 1;
  for (const auto& groupby_expr : groupby_exprs) {
    auto target_expr =
        var_ref(groupby_expr.get(), Analyzer::Var::kGROUPBY, group_key_idx++);
    target_exprs_owned.push_back(target_expr);
    target_exprs.push_back(target_expr.get());
  }

  for (const auto& target_rex_agg : aggregate->getAggExprs()) {
    auto target_expr =
        RelAlgTranslator::translateAggregateRex(target_rex_agg.get(), scalar_sources);
    CHECK(target_expr);
    target_expr = fold_expr(target_expr.get());
    target_exprs_owned.push_back(target_expr);
    target_exprs.push_back(target_expr.get());
  }
  return target_exprs;
}

Here is the call graph for this function: