anonymous_namespace{Execute.cpp} Namespace Reference

Classes
struct	GetTargetInfo
class	OutVecOwner

Functions
void	prepare_string_dictionaries (const std::unordered_set< PhysicalInput > &phys_inputs)
bool	is_empty_table (Fragmenter_Namespace::AbstractFragmenter *fragmenter)
void	log_system_memory_info_impl (std::string const &mem_log, size_t executor_id, size_t log_time_ms, std::string const &log_tag, size_t const thread_idx)
size_t	get_col_byte_width (const shared::ColumnKey &column_key)
ResultSetPtr	get_merged_result (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device, std::vector< TargetInfo > const &targets)
ReductionCode	get_reduction_code (const size_t executor_id, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device, int64_t *compilation_queue_time)
size_t	compute_buffer_entry_guess (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
std::string	get_table_name (const InputDescriptor &input_desc)
size_t	getDeviceBasedWatchdogScanLimit (size_t watchdog_max_projected_rows_per_device, const ExecutorDeviceType device_type, const int device_count)
void	checkWorkUnitWatchdog (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &table_infos, const ExecutorDeviceType device_type, const int device_count)
template<typename T >
std::vector< std::string >	expr_container_to_string (const T &expr_container)
template<>
std::vector< std::string >	expr_container_to_string (const std::list< Analyzer::OrderEntry > &expr_container)
std::string	sort_algorithm_to_string (const SortAlgorithm algorithm)
RelAlgExecutionUnit	replace_scan_limit (const RelAlgExecutionUnit &ra_exe_unit_in, const size_t new_scan_limit)
int64_t	inline_null_val (const SQLTypeInfo &ti, const bool float_argument_input)
void	fill_entries_for_empty_input (std::vector< TargetInfo > &target_infos, std::vector< int64_t > &entry, const std::vector< Analyzer::Expr * > &target_exprs, const QueryMemoryDescriptor &query_mem_desc)
ResultSetPtr	build_row_for_empty_input (const std::vector< Analyzer::Expr * > &target_exprs_in, const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type)
size_t	permute_storage_columnar (const ResultSetStorage *input_storage, const QueryMemoryDescriptor &input_query_mem_desc, const ResultSetStorage *output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)
size_t	permute_storage_row_wise (const ResultSetStorage *input_storage, const ResultSetStorage *output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)
bool	has_lazy_fetched_columns (const std::vector< ColumnLazyFetchInfo > &fetched_cols)
const ColumnDescriptor *	try_get_column_descriptor (const InputColDescriptor *col_desc)
size_t	get_selected_input_descs_index (const shared::TableKey &table_key, std::vector< InputDescriptor > const &input_descs)
size_t	get_selected_input_col_descs_index (const shared::TableKey &table_key, std::list< std::shared_ptr< InputColDescriptor const >> const &input_col_descs)
std::list< std::shared_ptr < const InputColDescriptor > >	get_selected_input_col_descs (const shared::TableKey &table_key, std::list< std::shared_ptr< InputColDescriptor const >> const &input_col_descs)
void	set_mod_range (std::vector< int8_t const * > &frag_col_buffers, int8_t const *const ptr, size_t const local_col_id, size_t const N)
bool	check_rows_less_than_needed (const ResultSetPtr &results, const size_t scan_limit)
void	add_deleted_col_to_map (PlanState::DeletedColumnsMap &deleted_cols_map, const ColumnDescriptor *deleted_cd, const shared::TableKey &table_key)
std::tuple< bool, int64_t, int64_t >	get_hpt_overflow_underflow_safe_scaled_values (const int64_t chunk_min, const int64_t chunk_max, const SQLTypeInfo &lhs_type, const SQLTypeInfo &rhs_type)

Function Documentation

void anonymous_namespace{Execute.cpp}::add_deleted_col_to_map	(	PlanState::DeletedColumnsMap &	deleted_cols_map,
		const ColumnDescriptor *	deleted_cd,
		const shared::TableKey &	table_key
	)

Definition at line 4463 of file Execute.cpp.

References CHECK, and CHECK_EQ.

Referenced by Executor::addDeletedColumn().

                                                             {
  auto deleted_cols_it = deleted_cols_map.find(table_key);
  if (deleted_cols_it == deleted_cols_map.end()) {
    CHECK(deleted_cols_map.insert(std::make_pair(table_key, deleted_cd)).second);
  } else {
    CHECK_EQ(deleted_cd, deleted_cols_it->second);
  }
}

Here is the caller graph for this function:

ResultSetPtr anonymous_namespace{Execute.cpp}::build_row_for_empty_input	(	const std::vector< Analyzer::Expr * > &	target_exprs_in,
		const QueryMemoryDescriptor &	query_mem_desc,
		const ExecutorDeviceType	device_type
	)

Definition at line 2673 of file Execute.cpp.

References CHECK, fill_entries_for_empty_input(), QueryMemoryDescriptor::getExecutor(), query_mem_desc, and SQLTypeInfo::set_notnull().

Referenced by Executor::collectAllDeviceResults().

                                          {
  std::vector<std::shared_ptr<Analyzer::Expr>> target_exprs_owned_copies;
  std::vector<Analyzer::Expr*> target_exprs;
  for (const auto target_expr : target_exprs_in) {
    const auto target_expr_copy =
        std::dynamic_pointer_cast<Analyzer::AggExpr>(target_expr->deep_copy());
    CHECK(target_expr_copy);
    auto ti = target_expr->get_type_info();
    ti.set_notnull(false);
    target_expr_copy->set_type_info(ti);
    if (target_expr_copy->get_arg()) {
      auto arg_ti = target_expr_copy->get_arg()->get_type_info();
      arg_ti.set_notnull(false);
      target_expr_copy->get_arg()->set_type_info(arg_ti);
    }
    target_exprs_owned_copies.push_back(target_expr_copy);
    target_exprs.push_back(target_expr_copy.get());
  }
  std::vector<TargetInfo> target_infos;
  std::vector<int64_t> entry;
  fill_entries_for_empty_input(target_infos, entry, target_exprs, query_mem_desc);
  const auto executor = query_mem_desc.getExecutor();
  CHECK(executor);
  // todo(yoonmin): Can we avoid initialize DramArena for this empty result case?
  auto row_set_mem_owner = executor->getRowSetMemoryOwner();
  CHECK(row_set_mem_owner);
  auto rs = std::make_shared<ResultSet>(target_infos,
                                        device_type,
                                        query_mem_desc,
                                        row_set_mem_owner,
                                        executor->blockSize(),
                                        executor->gridSize());
  rs->allocateStorage();
  rs->fillOneEntry(entry);
  return rs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{Execute.cpp}::check_rows_less_than_needed	(	const ResultSetPtr &	results,
		const size_t	scan_limit
	)

Definition at line 4054 of file Execute.cpp.

References CHECK.

Referenced by Executor::executePlanWithGroupBy().

                                                                                       {
  CHECK(scan_limit);
  return results && results->rowCount() < scan_limit;
}

Here is the caller graph for this function:

void anonymous_namespace{Execute.cpp}::checkWorkUnitWatchdog	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	table_infos,
		const ExecutorDeviceType	device_type,
		const int	device_count
	)

Definition at line 1847 of file Execute.cpp.

References SortInfo::algorithm, g_watchdog_max_projected_rows_per_device, foreign_storage::get_table_name(), getDeviceBasedWatchdogScanLimit(), RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::input_descs, RegisteredQueryHint::isHintRegistered(), join(), kWatchdogMaxProjectedRowsPerDevice, RelAlgExecutionUnit::query_hint, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::sort_info, StreamingTopN, RelAlgExecutionUnit::target_exprs, to_string(), RelAlgExecutionUnit::use_bump_allocator, VLOG, and RegisteredQueryHint::watchdog_max_projected_rows_per_device.

Referenced by Executor::createKernels().

                                                   {
  for (const auto target_expr : ra_exe_unit.target_exprs) {
    if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
      return;
    }
  }
  size_t watchdog_max_projected_rows_per_device =
      g_watchdog_max_projected_rows_per_device;
  if (ra_exe_unit.query_hint.isHintRegistered(
          QueryHint::kWatchdogMaxProjectedRowsPerDevice)) {
    watchdog_max_projected_rows_per_device =
        ra_exe_unit.query_hint.watchdog_max_projected_rows_per_device;
    VLOG(1) << "Set the watchdog per device maximum projection limit: "
            << watchdog_max_projected_rows_per_device << " by a query hint";
  }
  if (!ra_exe_unit.scan_limit && table_infos.size() == 1 &&
      table_infos.front().info.getPhysicalNumTuples() <
          watchdog_max_projected_rows_per_device) {
    // Allow a query with no scan limit to run on small tables
    return;
  }
  if (ra_exe_unit.use_bump_allocator) {
    // Bump allocator removes the scan limit (and any knowledge of the size of the output
    // relative to the size of the input), so we bypass this check for now
    return;
  }
  if (ra_exe_unit.sort_info.algorithm != SortAlgorithm::StreamingTopN &&
      ra_exe_unit.groupby_exprs.size() == 1 && !ra_exe_unit.groupby_exprs.front() &&
      (!ra_exe_unit.scan_limit ||
       ra_exe_unit.scan_limit >
           getDeviceBasedWatchdogScanLimit(
               watchdog_max_projected_rows_per_device, device_type, device_count))) {
    std::vector<std::string> table_names;
    const auto& input_descs = ra_exe_unit.input_descs;
    for (const auto& input_desc : input_descs) {
      table_names.push_back(get_table_name(input_desc));
    }
    if (!ra_exe_unit.scan_limit) {
      throw WatchdogException(
          "Projection query would require a scan without a limit on table(s): " +
          boost::algorithm::join(table_names, ", "));
    } else {
      throw WatchdogException(
          "Projection query output result set on table(s): " +
          boost::algorithm::join(table_names, ", ") + "  would contain " +
          std::to_string(ra_exe_unit.scan_limit) +
          " rows, which is more than the current system limit of " +
          std::to_string(getDeviceBasedWatchdogScanLimit(
              watchdog_max_projected_rows_per_device, device_type, device_count)));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::compute_buffer_entry_guess	(	const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

Definition at line 1778 of file Execute.cpp.

References CHECK, RelAlgExecutionUnit::scan_limit, and VLOG.

Referenced by Executor::executeWorkUnitImpl().

                                                                          {
  // we can use filtered_count_all's result if available
  if (ra_exe_unit.scan_limit) {
    VLOG(1)
        << "Exploiting a result of filtered count query as output buffer entry count: "
        << ra_exe_unit.scan_limit;
    return ra_exe_unit.scan_limit;
  }
  using Fragmenter_Namespace::FragmentInfo;
  using checked_size_t = boost::multiprecision::number<
      boost::multiprecision::cpp_int_backend<64,
                                             64,
                                             boost::multiprecision::unsigned_magnitude,
                                             boost::multiprecision::checked,
                                             void>>;
  checked_size_t checked_max_groups_buffer_entry_guess = 1;
  // Cap the rough approximation to 100M entries, it's unlikely we can do a great job for
  // baseline group layout with that many entries anyway.
  constexpr size_t max_groups_buffer_entry_guess_cap = 100000000;
  // Check for overflows since we're multiplying potentially big table sizes.
  try {
    for (const auto& table_info : query_infos) {
      CHECK(!table_info.info.fragments.empty());
      checked_size_t table_cardinality = 0;
      std::for_each(table_info.info.fragments.begin(),
                    table_info.info.fragments.end(),
                    [&table_cardinality](const FragmentInfo& frag_info) {
                      table_cardinality += frag_info.getNumTuples();
                    });
      checked_max_groups_buffer_entry_guess *= table_cardinality;
    }
  } catch (...) {
    checked_max_groups_buffer_entry_guess = max_groups_buffer_entry_guess_cap;
    VLOG(1) << "Detect overflow when approximating output buffer entry count, "
               "resetting it as "
            << max_groups_buffer_entry_guess_cap;
  }
  size_t max_groups_buffer_entry_guess =
      std::min(static_cast<size_t>(checked_max_groups_buffer_entry_guess),
               max_groups_buffer_entry_guess_cap);
  VLOG(1) << "Set an approximated output entry count as: "
          << max_groups_buffer_entry_guess;
  return max_groups_buffer_entry_guess;
}

Here is the caller graph for this function:

template<typename T >

std::vector<std::string> anonymous_namespace{Execute.cpp}::expr_container_to_string

(

const T &

expr_container

)

Definition at line 1923 of file Execute.cpp.

Referenced by operator<<().

                                                                       {
  std::vector<std::string> expr_strs;
  for (const auto& expr : expr_container) {
    if (!expr) {
      expr_strs.emplace_back("NULL");
    } else {
      expr_strs.emplace_back(expr->toString());
    }
  }
  return expr_strs;
}

Here is the caller graph for this function:

template<>

std::vector<std::string> anonymous_namespace{Execute.cpp}::expr_container_to_string

(

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

expr_container

)

Definition at line 1936 of file Execute.cpp.

                                                       {
  std::vector<std::string> expr_strs;
  for (const auto& expr : expr_container) {
    expr_strs.emplace_back(expr.toString());
  }
  return expr_strs;
}

void anonymous_namespace{Execute.cpp}::fill_entries_for_empty_input	(	std::vector< TargetInfo > &	target_infos,
		std::vector< int64_t > &	entry,
		const std::vector< Analyzer::Expr * > &	target_exprs,
		const QueryMemoryDescriptor &	query_mem_desc
	)

Definition at line 2615 of file Execute.cpp.

References Bitmap, CHECK, g_bigint_count, g_cluster, get_target_info(), QueryMemoryDescriptor::getCountDistinctDescriptor(), QueryMemoryDescriptor::getExecutor(), inline_null_val(), takes_float_argument(), and UnorderedSet.

Referenced by build_row_for_empty_input().

                                                                               {
  for (size_t target_idx = 0; target_idx < target_exprs.size(); ++target_idx) {
    const auto target_expr = target_exprs[target_idx];
    const auto agg_info = get_target_info(target_expr, g_bigint_count);
    CHECK(agg_info.is_agg);
    target_infos.push_back(agg_info);
    if (g_cluster) {
      const auto executor = query_mem_desc.getExecutor();
      CHECK(executor);
      auto row_set_mem_owner = executor->getRowSetMemoryOwner();
      CHECK(row_set_mem_owner);
      const auto& count_distinct_desc =
          query_mem_desc.getCountDistinctDescriptor(target_idx);
      if (count_distinct_desc.impl_type_ == CountDistinctImplType::Bitmap) {
        CHECK(row_set_mem_owner);
        // TODO: can we detect thread idx here?
        constexpr size_t thread_idx{0};
        const auto bitmap_size = count_distinct_desc.bitmapPaddedSizeBytes();
        row_set_mem_owner->initCountDistinctBufferAllocator(bitmap_size, thread_idx);
        auto count_distinct_buffer =
            row_set_mem_owner->allocateCountDistinctBuffer(bitmap_size, thread_idx);
        entry.push_back(reinterpret_cast<int64_t>(count_distinct_buffer));
        continue;
      }
      if (count_distinct_desc.impl_type_ == CountDistinctImplType::UnorderedSet) {
        auto count_distinct_set = new CountDistinctSet();
        CHECK(row_set_mem_owner);
        row_set_mem_owner->addCountDistinctSet(count_distinct_set);
        entry.push_back(reinterpret_cast<int64_t>(count_distinct_set));
        continue;
      }
    }
    const bool float_argument_input = takes_float_argument(agg_info);
    if (shared::is_any<kCOUNT, kCOUNT_IF, kAPPROX_COUNT_DISTINCT>(agg_info.agg_kind)) {
      entry.push_back(0);
    } else if (shared::is_any<kAVG>(agg_info.agg_kind)) {
      entry.push_back(0);
      entry.push_back(0);
    } else if (shared::is_any<kSINGLE_VALUE, kSAMPLE>(agg_info.agg_kind)) {
      if (agg_info.sql_type.is_geometry() && !agg_info.is_varlen_projection) {
        for (int i = 0; i < agg_info.sql_type.get_physical_coord_cols() * 2; i++) {
          entry.push_back(0);
        }
      } else if (agg_info.sql_type.is_varlen()) {
        entry.push_back(0);
        entry.push_back(0);
      } else {
        entry.push_back(inline_null_val(agg_info.sql_type, float_argument_input));
      }
    } else {
      entry.push_back(inline_null_val(agg_info.sql_type, float_argument_input));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::get_col_byte_width

(

const shared::ColumnKey &

column_key

)

Definition at line 791 of file Execute.cpp.

References Catalog_Namespace::get_metadata_for_column(), and shared::ColumnKey::table_id.

Referenced by Executor::getColumnByteWidthMap().

                                                             {
  if (column_key.table_id < 0) {
    // We have an intermediate results table

    // Todo(todd): Get more accurate representation of column width
    // for intermediate tables
    return size_t(8);
  } else {
    const auto cd = Catalog_Namespace::get_metadata_for_column(column_key);
    const auto& ti = cd->columnType;
    const auto sz = ti.get_size();
    if (sz < 0) {
      // for varlen types, only account for the pointer/size for each row, for now
      if (ti.is_logical_geo_type()) {
        // Don't count size for logical geo types, as they are
        // backed by physical columns
        return size_t(0);
      } else {
        return size_t(16);
      }
    } else {
      return sz;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::tuple<bool, int64_t, int64_t> anonymous_namespace{Execute.cpp}::get_hpt_overflow_underflow_safe_scaled_values	(	const int64_t	chunk_min,
		const int64_t	chunk_max,
		const SQLTypeInfo &	lhs_type,
		const SQLTypeInfo &	rhs_type
	)

Definition at line 4526 of file Execute.cpp.

References CHECK, SQLTypeInfo::get_dimension(), and DateTimeUtils::get_timestamp_precision_scale().

Referenced by Executor::skipFragment().

                                 {
  const int32_t ldim = lhs_type.get_dimension();
  const int32_t rdim = rhs_type.get_dimension();
  CHECK(ldim != rdim);
  const auto scale = DateTimeUtils::get_timestamp_precision_scale(abs(rdim - ldim));
  if (ldim > rdim) {
    // LHS type precision is more than RHS col type. No chance of overflow/underflow.
    return {true, chunk_min / scale, chunk_max / scale};
  }

  using checked_int64_t = boost::multiprecision::number<
      boost::multiprecision::cpp_int_backend<64,
                                             64,
                                             boost::multiprecision::signed_magnitude,
                                             boost::multiprecision::checked,
                                             void>>;

  try {
    auto ret =
        std::make_tuple(true,
                        int64_t(checked_int64_t(chunk_min) * checked_int64_t(scale)),
                        int64_t(checked_int64_t(chunk_max) * checked_int64_t(scale)));
    return ret;
  } catch (const std::overflow_error& e) {
    // noop
  }
  return std::make_tuple(false, chunk_min, chunk_max);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResultSetPtr anonymous_namespace{Execute.cpp}::get_merged_result	(	std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &	results_per_device,
		std::vector< TargetInfo > const &	targets
	)

Definition at line 1535 of file Execute.cpp.

References CHECK, and result_set::first_dict_encoded_idx().

Referenced by Executor::resultsUnion().

                                          {
  auto& first = results_per_device.front().first;
  CHECK(first);
  auto const first_target_idx = result_set::first_dict_encoded_idx(targets);
  if (first_target_idx) {
    first->translateDictEncodedColumns(targets, *first_target_idx);
  }
  for (size_t dev_idx = 1; dev_idx < results_per_device.size(); ++dev_idx) {
    const auto& next = results_per_device[dev_idx].first;
    CHECK(next);
    if (first_target_idx) {
      next->translateDictEncodedColumns(targets, *first_target_idx);
    }
    first->append(*next);
  }
  return std::move(first);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReductionCode anonymous_namespace{Execute.cpp}::get_reduction_code	(	const size_t	executor_id,
		std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &	results_per_device,
		int64_t *	compilation_queue_time
	)

Definition at line 1647 of file Execute.cpp.

References ResultSetReductionJIT::codegen(), timer_start(), and timer_stop().

Referenced by Executor::reduceMultiDeviceResultSets().

                                     {
  auto clock_begin = timer_start();
  // ResultSetReductionJIT::codegen compilation-locks if new code will be generated
  *compilation_queue_time = timer_stop(clock_begin);
  const auto& this_result_set = results_per_device[0].first;
  ResultSetReductionJIT reduction_jit(this_result_set->getQueryMemDesc(),
                                      this_result_set->getTargetInfos(),
                                      this_result_set->getTargetInitVals(),
                                      executor_id);
  return reduction_jit.codegen();
};

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<const InputColDescriptor> > anonymous_namespace{Execute.cpp}::get_selected_input_col_descs	(	const shared::TableKey &	table_key,
		std::list< std::shared_ptr< InputColDescriptor const >> const &	input_col_descs
	)

Definition at line 3614 of file Execute.cpp.

Referenced by Executor::fetchUnionChunks().

                                                                             {
  std::list<std::shared_ptr<const InputColDescriptor>> selected;
  for (auto const& input_col_desc : input_col_descs) {
    if (table_key == input_col_desc->getScanDesc().getTableKey()) {
      selected.push_back(input_col_desc);
    }
  }
  return selected;
}

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::get_selected_input_col_descs_index	(	const shared::TableKey &	table_key,
		std::list< std::shared_ptr< InputColDescriptor const >> const &	input_col_descs
	)

Definition at line 3603 of file Execute.cpp.

Referenced by Executor::fetchUnionChunks().

                                                                             {
  auto const has_table_key = [&table_key](auto const& input_desc) {
    return table_key == input_desc->getScanDesc().getTableKey();
  };
  return std::distance(
      input_col_descs.begin(),
      std::find_if(input_col_descs.begin(), input_col_descs.end(), has_table_key));
}

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::get_selected_input_descs_index	(	const shared::TableKey &	table_key,
		std::vector< InputDescriptor > const &	input_descs
	)

Definition at line 3594 of file Execute.cpp.

Referenced by Executor::fetchUnionChunks().

                                                                                     {
  auto const has_table_key = [&table_key](InputDescriptor const& input_desc) {
    return table_key == input_desc.getTableKey();
  };
  return std::find_if(input_descs.begin(), input_descs.end(), has_table_key) -
         input_descs.begin();
}

Here is the caller graph for this function:

std::string anonymous_namespace{Execute.cpp}::get_table_name

(

const InputDescriptor &

input_desc

)

Definition at line 1824 of file Execute.cpp.

References CHECK, CHECK_GT, Catalog_Namespace::get_metadata_for_table(), InputDescriptor::getSourceType(), InputDescriptor::getTableKey(), TABLE, shared::TableKey::table_id, and to_string().

                                                            {
  const auto source_type = input_desc.getSourceType();
  if (source_type == InputSourceType::TABLE) {
    const auto& table_key = input_desc.getTableKey();
    CHECK_GT(table_key.table_id, 0);
    const auto td = Catalog_Namespace::get_metadata_for_table(table_key);
    CHECK(td);
    return td->tableName;
  } else {
    return "$TEMPORARY_TABLE" + std::to_string(-input_desc.getTableKey().table_id);
  }
}

Here is the call graph for this function:

size_t anonymous_namespace{Execute.cpp}::getDeviceBasedWatchdogScanLimit ( size_t  watchdog_max_projected_rows_per_device, const ExecutorDeviceType  device_type, const int  device_count  )

inline

Definition at line 1837 of file Execute.cpp.

References GPU.

Referenced by checkWorkUnitWatchdog().

                            {
  if (device_type == ExecutorDeviceType::GPU) {
    return device_count * watchdog_max_projected_rows_per_device;
  }
  return watchdog_max_projected_rows_per_device;
}

Here is the caller graph for this function:

bool anonymous_namespace{Execute.cpp}::has_lazy_fetched_columns

(

const std::vector< ColumnLazyFetchInfo > &

fetched_cols

)

Definition at line 2896 of file Execute.cpp.

Referenced by Executor::createKernels().

                                                                                  {
  for (const auto& col : fetched_cols) {
    if (col.is_lazily_fetched) {
      return true;
    }
  }
  return false;
}

Here is the caller graph for this function:

int64_t anonymous_namespace{Execute.cpp}::inline_null_val	(	const SQLTypeInfo &	ti,
		const bool	float_argument_input
	)

Definition at line 2600 of file Execute.cpp.

References CHECK, SQLTypeInfo::get_type(), inline_fp_null_val(), inline_int_null_val(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_number(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), and kFLOAT.

Referenced by fill_entries_for_empty_input().

                                                                                {
  CHECK(ti.is_number() || ti.is_time() || ti.is_boolean() || ti.is_string());
  if (ti.is_fp()) {
    if (float_argument_input && ti.get_type() == kFLOAT) {
      int64_t float_null_val = 0;
      *reinterpret_cast<float*>(may_alias_ptr(&float_null_val)) =
          static_cast<float>(inline_fp_null_val(ti));
      return float_null_val;
    }
    const auto double_null_val = inline_fp_null_val(ti);
    return *reinterpret_cast<const int64_t*>(may_alias_ptr(&double_null_val));
  }
  return inline_int_null_val(ti);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{Execute.cpp}::is_empty_table

(

Fragmenter_Namespace::AbstractFragmenter *

fragmenter

)

Definition at line 227 of file Execute.cpp.

Referenced by foreign_storage::populate_string_dictionary().

                                                                        {
  const auto& fragments = fragmenter->getFragmentsForQuery().fragments;
  // The fragmenter always returns at least one fragment, even when the table is empty.
  return (fragments.size() == 1 && fragments[0].getChunkMetadataMap().empty());
}

Here is the caller graph for this function:

void anonymous_namespace{Execute.cpp}::log_system_memory_info_impl	(	std::string const &	mem_log,
		size_t	executor_id,
		size_t	log_time_ms,
		std::string const &	log_tag,
		size_t const	thread_idx
	)

Definition at line 752 of file Execute.cpp.

References VLOG.

Referenced by Executor::logSystemCPUMemoryStatus(), and Executor::logSystemGPUMemoryStatus().

                                                          {
  std::ostringstream oss;
  oss << mem_log;
  oss << " (" << log_tag << ", EXECUTOR-" << executor_id << ", THREAD-" << thread_idx
      << ", TOOK: " << log_time_ms << " ms)";
  VLOG(1) << oss.str();
}

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::permute_storage_columnar	(	const ResultSetStorage *	input_storage,
		const QueryMemoryDescriptor &	input_query_mem_desc,
		const ResultSetStorage *	output_storage,
		size_t	output_row_index,
		const QueryMemoryDescriptor &	output_query_mem_desc,
		const std::vector< uint32_t > &	top_permutation
	)

This functions uses the permutation indices in "top_permutation", and permutes all group columns (if any) and aggregate columns into the output storage. In columnar layout, since different columns are not consecutive in the memory, different columns are copied back into the output storage separetely and through different memcpy operations.

output_row_index contains the current index of the output storage (input storage will be appended to it), and the final output row index is returned.

Definition at line 2759 of file Execute.cpp.

References QueryMemoryDescriptor::getColOffInBytes(), QueryMemoryDescriptor::getKeyCount(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getPrependedGroupColOffInBytes(), QueryMemoryDescriptor::getSlotCount(), ResultSetStorage::getUnderlyingBuffer(), and QueryMemoryDescriptor::groupColWidth().

Referenced by Executor::collectAllDeviceShardedTopResults().

                                                                            {
  const auto output_buffer = output_storage->getUnderlyingBuffer();
  const auto input_buffer = input_storage->getUnderlyingBuffer();
  for (const auto sorted_idx : top_permutation) {
    // permuting all group-columns in this result set into the final buffer:
    for (size_t group_idx = 0; group_idx < input_query_mem_desc.getKeyCount();
         group_idx++) {
      const auto input_column_ptr =
          input_buffer + input_query_mem_desc.getPrependedGroupColOffInBytes(group_idx) +
          sorted_idx * input_query_mem_desc.groupColWidth(group_idx);
      const auto output_column_ptr =
          output_buffer +
          output_query_mem_desc.getPrependedGroupColOffInBytes(group_idx) +
          output_row_index * output_query_mem_desc.groupColWidth(group_idx);
      memcpy(output_column_ptr,
             input_column_ptr,
             output_query_mem_desc.groupColWidth(group_idx));
    }
    // permuting all agg-columns in this result set into the final buffer:
    for (size_t slot_idx = 0; slot_idx < input_query_mem_desc.getSlotCount();
         slot_idx++) {
      const auto input_column_ptr =
          input_buffer + input_query_mem_desc.getColOffInBytes(slot_idx) +
          sorted_idx * input_query_mem_desc.getPaddedSlotWidthBytes(slot_idx);
      const auto output_column_ptr =
          output_buffer + output_query_mem_desc.getColOffInBytes(slot_idx) +
          output_row_index * output_query_mem_desc.getPaddedSlotWidthBytes(slot_idx);
      memcpy(output_column_ptr,
             input_column_ptr,
             output_query_mem_desc.getPaddedSlotWidthBytes(slot_idx));
    }
    ++output_row_index;
  }
  return output_row_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{Execute.cpp}::permute_storage_row_wise	(	const ResultSetStorage *	input_storage,
		const ResultSetStorage *	output_storage,
		size_t	output_row_index,
		const QueryMemoryDescriptor &	output_query_mem_desc,
		const std::vector< uint32_t > &	top_permutation
	)

This functions uses the permutation indices in "top_permutation", and permutes all group columns (if any) and aggregate columns into the output storage. In row-wise, since different columns are consecutive within the memory, it suffices to perform a single memcpy operation and copy the whole row.

output_row_index contains the current index of the output storage (input storage will be appended to it), and the final output row index is returned.

Definition at line 2809 of file Execute.cpp.

References QueryMemoryDescriptor::getRowSize(), and ResultSetStorage::getUnderlyingBuffer().

Referenced by Executor::collectAllDeviceShardedTopResults().

                                                                            {
  const auto output_buffer = output_storage->getUnderlyingBuffer();
  const auto input_buffer = input_storage->getUnderlyingBuffer();
  for (const auto sorted_idx : top_permutation) {
    const auto row_ptr = input_buffer + sorted_idx * output_query_mem_desc.getRowSize();
    memcpy(output_buffer + output_row_index * output_query_mem_desc.getRowSize(),
           row_ptr,
           output_query_mem_desc.getRowSize());
    ++output_row_index;
  }
  return output_row_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{Execute.cpp}::prepare_string_dictionaries

(

const std::unordered_set< PhysicalInput > &

phys_inputs

)

Definition at line 221 of file Execute.cpp.

Referenced by Executor::computeStringDictionaryGenerations(), and anonymous_namespace{RelAlgExecutor.cpp}::prepare_foreign_table_for_execution().

                                                                                     {
  for (const auto [col_id, table_id, db_id] : phys_inputs) {
    foreign_storage::populate_string_dictionary(table_id, col_id, db_id);
  }
}

Here is the caller graph for this function:

RelAlgExecutionUnit anonymous_namespace{Execute.cpp}::replace_scan_limit	(	const RelAlgExecutionUnit &	ra_exe_unit_in,
		const size_t	new_scan_limit
	)

Definition at line 2075 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::hash_table_build_plan_dag, RelAlgExecutionUnit::input_col_descs, RelAlgExecutionUnit::input_descs, RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::query_hint, RelAlgExecutionUnit::query_plan_dag_hash, RelAlgExecutionUnit::query_state, RelAlgExecutionUnit::simple_quals, RelAlgExecutionUnit::sort_info, RelAlgExecutionUnit::table_id_to_node_map, RelAlgExecutionUnit::target_exprs, RelAlgExecutionUnit::target_exprs_original_type_infos, RelAlgExecutionUnit::union_all, and RelAlgExecutionUnit::use_bump_allocator.

Referenced by Executor::executeWorkUnit().

                                                                    {
  return {ra_exe_unit_in.input_descs,
          ra_exe_unit_in.input_col_descs,
          ra_exe_unit_in.simple_quals,
          ra_exe_unit_in.quals,
          ra_exe_unit_in.join_quals,
          ra_exe_unit_in.groupby_exprs,
          ra_exe_unit_in.target_exprs,
          ra_exe_unit_in.target_exprs_original_type_infos,
          ra_exe_unit_in.estimator,
          ra_exe_unit_in.sort_info,
          new_scan_limit,
          ra_exe_unit_in.query_hint,
          ra_exe_unit_in.query_plan_dag_hash,
          ra_exe_unit_in.hash_table_build_plan_dag,
          ra_exe_unit_in.table_id_to_node_map,
          ra_exe_unit_in.use_bump_allocator,
          ra_exe_unit_in.union_all,
          ra_exe_unit_in.query_state};
}

Here is the caller graph for this function:

void anonymous_namespace{Execute.cpp}::set_mod_range	(	std::vector< int8_t const * > &	frag_col_buffers,
		int8_t const *const	ptr,
		size_t const	local_col_id,
		size_t const	N
	)

Definition at line 3627 of file Execute.cpp.

References CHECK_LE, and anonymous_namespace{Utm.h}::N.

Referenced by Executor::fetchUnionChunks().

                                   {
  size_t const begin = local_col_id - local_col_id % N;  // N divides begin
  size_t const end = begin + N;
  CHECK_LE(end, frag_col_buffers.size()) << (void*)ptr << ' ' << local_col_id << ' ' << N;
  for (size_t i = begin; i < end; ++i) {
    frag_col_buffers[i] = ptr;
  }
}

Here is the caller graph for this function:

std::string anonymous_namespace{Execute.cpp}::sort_algorithm_to_string

(

const SortAlgorithm

algorithm

)

Definition at line 1945 of file Execute.cpp.

References Default, SpeculativeTopN, StreamingTopN, and UNREACHABLE.

Referenced by operator<<().

                                                                  {
  switch (algorithm) {
    case SortAlgorithm::Default:
      return "ResultSet";
    case SortAlgorithm::SpeculativeTopN:
      return "Speculative Top N";
    case SortAlgorithm::StreamingTopN:
      return "Streaming Top N";
  }
  UNREACHABLE();
  return "";
}

Here is the caller graph for this function:

const ColumnDescriptor* anonymous_namespace{Execute.cpp}::try_get_column_descriptor

(

const InputColDescriptor *

col_desc

)

Definition at line 3340 of file Execute.cpp.

References get_column_descriptor_maybe(), InputColDescriptor::getColId(), InputColDescriptor::getScanDesc(), and InputDescriptor::getTableKey().

Referenced by Executor::fetchChunks(), and Executor::fetchUnionChunks().

                                                                                      {
  const auto& table_key = col_desc->getScanDesc().getTableKey();
  const auto col_id = col_desc->getColId();
  return get_column_descriptor_maybe({table_key, col_id});
}

Here is the call graph for this function:

Here is the caller graph for this function: