anonymous_namespace{QueryMemoryDescriptor.cpp} Namespace Reference

Functions
bool	is_int_and_no_bigger_than (const SQLTypeInfo &ti, const size_t byte_width)
bool	is_valid_int32_range (const ExpressionRange &range)
std::vector< int64_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< int64_t >	target_expr_proj_indices (const RelAlgExecutionUnit &ra_exe_unit)
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)
bool	use_streaming_top_n (const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
template<class T >
std::vector< int8_t >	get_col_byte_widths (const T &col_expr_list)
template<SQLAgg... agg_types>
bool	any_of (std::vector< Analyzer::Expr * > const &target_exprs)

Function Documentation

template<SQLAgg... agg_types>

bool anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of

(

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

target_exprs

)

Definition at line 437 of file QueryMemoryDescriptor.cpp.

Referenced by import_export::TypedImportBuffer::add_values(), ResultSet::areAnyColumnsLazyFetched(), Executor::codegenJoinLoops(), RelAlgExecutor::executeUnion(), QueryPlanDagExtractor::handleLeftDeepJoinTree(), Analyzer::WindowFunction::hasAggregateTreeRequiredWindowFunc(), HashingSchemeRecycler::hasItemInCache(), QueryMemoryInitializer::initRowGroups(), anonymous_namespace{DdlCommandExecutor.cpp}::is_default_server(), OverlapsJoinSupportedFunction::is_many_to_many_func(), OverlapsJoinSupportedFunction::is_overlaps_supported_func(), OverlapsJoinSupportedFunction::is_point_poly_rewrite_target_func(), OverlapsJoinSupportedFunction::is_poly_mpoly_rewrite_target_func(), OverlapsJoinSupportedFunction::is_poly_point_rewrite_target_func(), OverlapsJoinSupportedFunction::is_range_join_rewrite_target_func(), anonymous_namespace{RelAlgExecutor.cpp}::is_window_execution_unit(), RegisteredQueryHint::isAnyQueryHintDelivered(), Analyzer::WindowFunction::isFrameNavigateWindowFunction(), Analyzer::WindowFunction::isFramingAvailableWindowFunc(), and HashtableRecycler::isInvalidHashTableCacheKey().

                                                          {
  return boost::algorithm::any_of(target_exprs, [=](Analyzer::Expr const* expr) {
    auto const* const agg = dynamic_cast<Analyzer::AggExpr const*>(expr);
    return agg && (... || (agg_types == agg->get_aggtype()));
  });
}

Here is the caller graph for this function:

template<class T >

std::vector<int8_t> anonymous_namespace{QueryMemoryDescriptor.cpp}::get_col_byte_widths ( const T &  col_expr_list )

inline

Definition at line 184 of file QueryMemoryDescriptor.cpp.

References CHECK, CHECK_EQ, g_bigint_count, get_bit_width(), get_compact_type(), get_target_info(), anonymous_namespace{TargetExprBuilder.cpp}::is_varlen_projection(), kAVG, kENCODING_NONE, and heavydb.dtypes::T.

Referenced by QueryMemoryDescriptor::init(), and QueryMemoryDescriptor::pick_target_compact_width().

                                                                     {
  std::vector<int8_t> col_widths;
  size_t col_expr_idx = 0;
  for (const auto& col_expr : col_expr_list) {
    if (!col_expr) {
      // row index
      col_widths.push_back(sizeof(int64_t));
    } else {
      bool is_varlen_projection{false};
      if constexpr (std::is_same<T, std::list<std::shared_ptr<Analyzer::Expr>>>::value) {
        is_varlen_projection =
            !(std::dynamic_pointer_cast<const Analyzer::GeoExpr>(col_expr) == nullptr);
      } else {
        is_varlen_projection =
            !(dynamic_cast<const Analyzer::GeoExpr*>(col_expr) == nullptr);
      }

      if (is_varlen_projection) {
        col_widths.push_back(sizeof(int64_t));
        ++col_expr_idx;
        continue;
      }
      const auto agg_info = get_target_info(col_expr, g_bigint_count);
      const auto chosen_type = get_compact_type(agg_info);
      if ((chosen_type.is_string() && chosen_type.get_compression() == kENCODING_NONE) ||
          chosen_type.is_array()) {
        col_widths.push_back(sizeof(int64_t));
        col_widths.push_back(sizeof(int64_t));
        ++col_expr_idx;
        continue;
      }
      if (chosen_type.is_geometry()) {
        for (auto i = 0; i < chosen_type.get_physical_coord_cols(); ++i) {
          col_widths.push_back(sizeof(int64_t));
          col_widths.push_back(sizeof(int64_t));
        }
        ++col_expr_idx;
        continue;
      }
      const auto col_expr_bitwidth = get_bit_width(chosen_type);
      CHECK_EQ(size_t(0), col_expr_bitwidth % 8);
      col_widths.push_back(static_cast<int8_t>(col_expr_bitwidth >> 3));
      // for average, we'll need to keep the count as well
      if (agg_info.agg_kind == kAVG) {
        CHECK(agg_info.is_agg);
        col_widths.push_back(sizeof(int64_t));
      }
    }
    ++col_expr_idx;
  }
  return col_widths;
}

Here is the call graph for this function:

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 34 of file QueryMemoryDescriptor.cpp.

References get_bit_width(), and SQLTypeInfo::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:

bool anonymous_namespace{QueryMemoryDescriptor.cpp}::is_valid_int32_range

(

const ExpressionRange &

range

)

Definition at line 41 of file QueryMemoryDescriptor.cpp.

References EMPTY_KEY_32, ExpressionRange::getIntMax(), and ExpressionRange::getIntMin().

Referenced by pick_baseline_key_component_width().

                                                        {
  return range.getIntMin() > INT32_MIN && range.getIntMax() < EMPTY_KEY_32 - 1;
}

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, Float, ExpressionRange::getType(), ExpressionRange::hasNulls(), Integer, Invalid, is_valid_int32_range(), 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 is_valid_int32_range(range) ? 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::vector<int64_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 45 of file QueryMemoryDescriptor.cpp.

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

                                                  {
  std::vector<int64_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<int64_t> anonymous_namespace{QueryMemoryDescriptor.cpp}::target_expr_proj_indices

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 63 of file QueryMemoryDescriptor.cpp.

References CHECK, get_column_descriptor_maybe(), RelAlgExecutionUnit::input_descs, 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<int64_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->getColumnKey());
      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();
    // TODO: add proper lazy fetch for varlen types in result set
    if (ti.is_varlen()) {
      continue;
    }
    const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
    if (!col_var) {
      continue;
    }
    if (!ti.is_varlen() &&
        used_columns.find(col_var->getColumnKey().column_id) == used_columns.end()) {
      // setting target index to be zero so that later it can be decoded properly (in lazy
      // fetch, the zeroth target index indicates the corresponding rowid column for the
      // projected entry)
      target_indices[target_idx] = 0;
    }
  }
  return target_indices;
}

Here is the call graph for this function:

bool anonymous_namespace{QueryMemoryDescriptor.cpp}::use_streaming_top_n	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const bool	output_columnar
	)

Definition at line 148 of file QueryMemoryDescriptor.cpp.

References SortInfo::algorithm, CHECK_GT, CHECK_LE, g_cluster, g_streaming_topn_max, SortInfo::limit, anonymous_namespace{Utm.h}::n, SortInfo::offset, SortInfo::order_entries, RelAlgExecutionUnit::sort_info, StreamingTopN, and RelAlgExecutionUnit::target_exprs.

                                                     {
  if (g_cluster) {
    return false;  // TODO(miyu)
  }

  for (const auto target_expr : ra_exe_unit.target_exprs) {
    if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
      return false;
    }
    if (dynamic_cast<const Analyzer::WindowFunction*>(target_expr)) {
      return false;
    }
  }

  // TODO: Allow streaming top n for columnar output
  if (!output_columnar && ra_exe_unit.sort_info.order_entries.size() == 1 &&
      ra_exe_unit.sort_info.limit &&
      ra_exe_unit.sort_info.algorithm == SortAlgorithm::StreamingTopN) {
    const auto only_order_entry = ra_exe_unit.sort_info.order_entries.front();
    CHECK_GT(only_order_entry.tle_no, int(0));
    CHECK_LE(static_cast<size_t>(only_order_entry.tle_no),
             ra_exe_unit.target_exprs.size());
    const auto order_entry_expr = ra_exe_unit.target_exprs[only_order_entry.tle_no - 1];
    const auto n = ra_exe_unit.sort_info.offset + ra_exe_unit.sort_info.limit;
    if ((order_entry_expr->get_type_info().is_number() ||
         order_entry_expr->get_type_info().is_time()) &&
        n <= g_streaming_topn_max) {
      return true;
    }
  }

  return false;
}