anonymous_namespace{QueryMemoryDescriptor.cpp} Namespace Reference

Functions
bool	is_int_and_no_bigger_than (const SQLTypeInfo &ti, const size_t byte_width)
std::vector< ssize_t >	target_expr_group_by_indices (const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const std::vector< Analyzer::Expr * > &target_exprs)
std::vector< ssize_t >	target_expr_proj_indices (const RelAlgExecutionUnit &ra_exe_unit, const Catalog_Namespace::Catalog &cat)
int8_t	pick_baseline_key_component_width (const ExpressionRange &range, const size_t group_col_width)
int8_t	pick_baseline_key_width (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Executor *executor)
std::string	boolToString (const bool val)
std::string	queryDescTypeToString (const QueryDescriptionType val)

Function Documentation

std::string anonymous_namespace{QueryMemoryDescriptor.cpp}::boolToString ( const bool  val )

inline

Definition at line 1111 of file QueryMemoryDescriptor.cpp.

Referenced by QueryMemoryDescriptor::reductionKey(), and QueryMemoryDescriptor::toString().

                                              {
  return val ? "True" : "False";
}

Here is the caller graph for this function:

bool anonymous_namespace{QueryMemoryDescriptor.cpp}::is_int_and_no_bigger_than	(	const SQLTypeInfo &	ti,
		const size_t	byte_width
	)

Definition at line 31 of file QueryMemoryDescriptor.cpp.

References get_bit_width(), and SQLTypeInfoCore< TYPE_FACET_PACK >::is_integer().

Referenced by QueryMemoryDescriptor::pick_target_compact_width().

                                                                               {
  if (!ti.is_integer()) {
    return false;
  }
  return get_bit_width(ti) <= (byte_width * 8);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int8_t anonymous_namespace{QueryMemoryDescriptor.cpp}::pick_baseline_key_component_width	(	const ExpressionRange &	range,
		const size_t	group_col_width
	)

Definition at line 114 of file QueryMemoryDescriptor.cpp.

References Double, EMPTY_KEY_32, Float, ExpressionRange::getIntMax(), ExpressionRange::getType(), ExpressionRange::hasNulls(), Integer, Invalid, and UNREACHABLE.

Referenced by pick_baseline_key_width().

                                                                       {
  if (range.getType() == ExpressionRangeType::Invalid) {
    return sizeof(int64_t);
  }
  switch (range.getType()) {
    case ExpressionRangeType::Integer:
      if (group_col_width == sizeof(int64_t) && range.hasNulls()) {
        return sizeof(int64_t);
      }
      return range.getIntMax() < EMPTY_KEY_32 - 1 ? sizeof(int32_t) : sizeof(int64_t);
    case ExpressionRangeType::Float:
    case ExpressionRangeType::Double:
      return sizeof(int64_t);  // No compaction for floating point yet.
    default:
      UNREACHABLE();
  }
  return sizeof(int64_t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int8_t anonymous_namespace{QueryMemoryDescriptor.cpp}::pick_baseline_key_width	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	query_infos,
		const Executor *	executor
	)

Definition at line 135 of file QueryMemoryDescriptor.cpp.

References getExpressionRange(), RelAlgExecutionUnit::groupby_exprs, and pick_baseline_key_component_width().

                                                         {
  int8_t compact_width{4};
  for (const auto groupby_expr : ra_exe_unit.groupby_exprs) {
    const auto expr_range = getExpressionRange(groupby_expr.get(), query_infos, executor);
    compact_width = std::max(compact_width,
                             pick_baseline_key_component_width(
                                 expr_range, groupby_expr->get_type_info().get_size()));
  }
  return compact_width;
}

Here is the call graph for this function:

std::string anonymous_namespace{QueryMemoryDescriptor.cpp}::queryDescTypeToString ( const QueryDescriptionType  val )

inline

Definition at line 1115 of file QueryMemoryDescriptor.cpp.

References Estimator, GroupByBaselineHash, GroupByPerfectHash, NonGroupedAggregate, Projection, and UNREACHABLE.

Referenced by QueryMemoryDescriptor::reductionKey().

                                                                       {
  switch (val) {
    case QueryDescriptionType::GroupByPerfectHash:
      return "Perfect Hash";
    case QueryDescriptionType::GroupByBaselineHash:
      return "Baseline Hash";
    case QueryDescriptionType::Projection:
      return "Projection";
    case QueryDescriptionType::NonGroupedAggregate:
      return "Non-grouped Aggregate";
    case QueryDescriptionType::Estimator:
      return "Estimator";
    default:
      UNREACHABLE();
  }
  return "";
}

Here is the caller graph for this function:

std::vector<ssize_t> anonymous_namespace{QueryMemoryDescriptor.cpp}::target_expr_group_by_indices	(	const std::list< std::shared_ptr< Analyzer::Expr >> &	groupby_exprs,
		const std::vector< Analyzer::Expr * > &	target_exprs
	)

Definition at line 38 of file QueryMemoryDescriptor.cpp.

References Analyzer::Var::get_varno(), and Analyzer::Var::kGROUPBY.

                                                  {
  std::vector<ssize_t> indices(target_exprs.size(), -1);
  for (size_t target_idx = 0; target_idx < target_exprs.size(); ++target_idx) {
    const auto target_expr = target_exprs[target_idx];
    if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
      continue;
    }
    const auto var_expr = dynamic_cast<const Analyzer::Var*>(target_expr);
    if (var_expr && var_expr->get_which_row() == Analyzer::Var::kGROUPBY) {
      indices[target_idx] = var_expr->get_varno() - 1;
      continue;
    }
  }
  return indices;
}

Here is the call graph for this function:

std::vector<ssize_t> anonymous_namespace{QueryMemoryDescriptor.cpp}::target_expr_proj_indices	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const Catalog_Namespace::Catalog &	cat
	)

Definition at line 56 of file QueryMemoryDescriptor.cpp.

References CHECK(), get_column_descriptor_maybe(), RelAlgExecutionUnit::input_descs, is_real_str_or_array(), kENCODING_NONE, SortInfo::order_entries, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::simple_quals, RelAlgExecutionUnit::sort_info, RelAlgExecutionUnit::target_exprs, and ScalarExprVisitor< T >::visit().

                                                                                   {
  if (ra_exe_unit.input_descs.size() > 1 ||
      !ra_exe_unit.sort_info.order_entries.empty()) {
    return {};
  }
  std::vector<ssize_t> target_indices(ra_exe_unit.target_exprs.size(), -1);
  UsedColumnsVisitor columns_visitor;
  std::unordered_set<int> used_columns;
  for (const auto& simple_qual : ra_exe_unit.simple_quals) {
    const auto crt_used_columns = columns_visitor.visit(simple_qual.get());
    used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
  }
  for (const auto& qual : ra_exe_unit.quals) {
    const auto crt_used_columns = columns_visitor.visit(qual.get());
    used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
  }
  for (const auto& target : ra_exe_unit.target_exprs) {
    const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target);
    if (col_var) {
      const auto cd = get_column_descriptor_maybe(
          col_var->get_column_id(), col_var->get_table_id(), cat);
      if (!cd || !cd->isVirtualCol) {
        continue;
      }
    }
    const auto crt_used_columns = columns_visitor.visit(target);
    used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
  }
  for (size_t target_idx = 0; target_idx < ra_exe_unit.target_exprs.size();
       ++target_idx) {
    const auto target_expr = ra_exe_unit.target_exprs[target_idx];
    CHECK(target_expr);
    const auto& ti = target_expr->get_type_info();
    const bool is_real_str_or_array =
        (ti.is_string() && ti.get_compression() == kENCODING_NONE) || ti.is_array();
    if (is_real_str_or_array) {
      continue;
    }
    if (ti.is_geometry()) {
      // TODO(adb): Ideally we could determine which physical columns are required for a
      // given query and fetch only those. For now, we bail on the memory optimization,
      // since it is possible that adding the physical columns could have unintended
      // consequences further down the execution path.
      return {};
    }
    const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
    if (!col_var) {
      continue;
    }
    if (!is_real_str_or_array &&
        used_columns.find(col_var->get_column_id()) == used_columns.end()) {
      target_indices[target_idx] = 0;
    }
  }
  return target_indices;
}

Here is the call graph for this function: