anonymous_namespace{ResultSetIteration.cpp} Namespace Reference

Classes
struct	GeoLazyFetchHandler
struct	GeoQueryOutputFetchHandler
struct	GeoTargetValueBuilder

Functions
TargetValue	make_avg_target_value (const int8_t *ptr1, const int8_t compact_sz1, const int8_t *ptr2, const int8_t compact_sz2, const TargetInfo &target_info)
const int8_t *	advance_col_buff_to_slot (const int8_t *buff, const QueryMemoryDescriptor &query_mem_desc, const std::vector< TargetInfo > &targets, const size_t slot_idx, const bool separate_varlen_storage)
const int8_t *	columnar_elem_ptr (const size_t entry_idx, const int8_t *col1_ptr, const int8_t compact_sz1)
int64_t	int_resize_cast (const int64_t ival, const size_t sz)
template<class T >
ScalarTargetValue	make_scalar_tv (const T val)
template<>
ScalarTargetValue	make_scalar_tv (const float val)
template<>
ScalarTargetValue	make_scalar_tv (const double val)
template<class T >
TargetValue	build_array_target_value (const int8_t *buff, const size_t buff_sz, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner)
TargetValue	build_string_array_target_value (const int32_t *buff, const size_t buff_sz, const int dict_id, const bool translate_strings, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const Catalog_Namespace::Catalog *catalog)
TargetValue	build_array_target_value (const SQLTypeInfo &array_ti, const int8_t *buff, const size_t buff_sz, const bool translate_strings, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const Catalog_Namespace::Catalog *catalog)
template<class Tuple , size_t... indices>
std::vector< std::pair< const int8_t *, const int64_t > >	make_vals_vector (std::index_sequence< indices...>, const Tuple &tuple)
std::unique_ptr< ArrayDatum >	lazy_fetch_chunk (const int8_t *ptr, const int64_t varlen_ptr)
std::unique_ptr< ArrayDatum >	fetch_data_from_gpu (int64_t varlen_ptr, const int64_t length, Data_Namespace::DataMgr *data_mgr, const int device_id)
template<typename T >
std::pair< int64_t, int64_t >	get_frag_id_and_local_idx (const std::vector< std::vector< T >> &frag_offsets, const size_t tab_or_col_idx, const int64_t global_idx)
double	calculate_quantile (int8_t const *ptr, double const q)
template<typename T >
size_t	make_bin_search (size_t l, size_t r, T &&is_empty_fn)

Function Documentation

const int8_t* anonymous_namespace{ResultSetIteration.cpp}::advance_col_buff_to_slot	(	const int8_t *	buff,
		const QueryMemoryDescriptor &	query_mem_desc,
		const std::vector< TargetInfo > &	targets,
		const size_t	slot_idx,
		const bool	separate_varlen_storage
	)

Definition at line 83 of file ResultSetIteration.cpp.

References advance_slot(), advance_to_next_columnar_target_buff(), CHECK, CHECK_LT, get_cols_ptr(), QueryMemoryDescriptor::getBufferColSlotCount(), and kAVG.

Referenced by ResultSetStorage::isEmptyEntryColumnar().

                                                                           {
  auto crt_col_ptr = get_cols_ptr(buff, query_mem_desc);
  const auto buffer_col_count = query_mem_desc.getBufferColSlotCount();
  size_t agg_col_idx{0};
  for (size_t target_idx = 0; target_idx < targets.size(); ++target_idx) {
    if (agg_col_idx == slot_idx) {
      return crt_col_ptr;
    }
    CHECK_LT(agg_col_idx, buffer_col_count);
    const auto& agg_info = targets[target_idx];
    crt_col_ptr =
        advance_to_next_columnar_target_buff(crt_col_ptr, query_mem_desc, agg_col_idx);
    if (agg_info.is_agg && agg_info.agg_kind == kAVG) {
      if (agg_col_idx + 1 == slot_idx) {
        return crt_col_ptr;
      }
      crt_col_ptr = advance_to_next_columnar_target_buff(
          crt_col_ptr, query_mem_desc, agg_col_idx + 1);
    }
    agg_col_idx = advance_slot(agg_col_idx, agg_info, separate_varlen_storage);
  }
  CHECK(false);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

TargetValue anonymous_namespace{ResultSetIteration.cpp}::build_array_target_value	(	const int8_t *	buff,
		const size_t	buff_sz,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner
	)

Definition at line 780 of file ResultSetIteration.cpp.

References CHECK_EQ, and omnisci.dtypes::T.

Referenced by ResultSet::makeVarlenTargetValue().

                                                        {
  std::vector<ScalarTargetValue> values;
  auto buff_elems = reinterpret_cast<const T*>(buff);
  CHECK_EQ(size_t(0), buff_sz % sizeof(T));
  const size_t num_elems = buff_sz / sizeof(T);
  for (size_t i = 0; i < num_elems; ++i) {
    values.push_back(make_scalar_tv<T>(buff_elems[i]));
  }
  return ArrayTargetValue(values);
}

Here is the caller graph for this function:

TargetValue anonymous_namespace{ResultSetIteration.cpp}::build_array_target_value	(	const SQLTypeInfo &	array_ti,
		const int8_t *	buff,
		const size_t	buff_sz,
		const bool	translate_strings,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const Catalog_Namespace::Catalog *	catalog
	)

Definition at line 830 of file ResultSetIteration.cpp.

References build_string_array_target_value(), CHECK, SQLTypeInfo::get_elem_type(), and SQLTypeInfo::is_array().

                                                                              {
  CHECK(array_ti.is_array());
  const auto& elem_ti = array_ti.get_elem_type();
  if (elem_ti.is_string()) {
    return build_string_array_target_value(reinterpret_cast<const int32_t*>(buff),
                                           buff_sz,
                                           elem_ti.get_comp_param(),
                                           translate_strings,
                                           row_set_mem_owner,
                                           catalog);
  }
  switch (elem_ti.get_size()) {
    case 1:
      return build_array_target_value<int8_t>(buff, buff_sz, row_set_mem_owner);
    case 2:
      return build_array_target_value<int16_t>(buff, buff_sz, row_set_mem_owner);
    case 4:
      if (elem_ti.is_fp()) {
        return build_array_target_value<float>(buff, buff_sz, row_set_mem_owner);
      } else {
        return build_array_target_value<int32_t>(buff, buff_sz, row_set_mem_owner);
      }
    case 8:
      if (elem_ti.is_fp()) {
        return build_array_target_value<double>(buff, buff_sz, row_set_mem_owner);
      } else {
        return build_array_target_value<int64_t>(buff, buff_sz, row_set_mem_owner);
      }
    default:
      CHECK(false);
  }
  CHECK(false);
  return TargetValue(nullptr);
}

Here is the call graph for this function:

TargetValue anonymous_namespace{ResultSetIteration.cpp}::build_string_array_target_value	(	const int32_t *	buff,
		const size_t	buff_sz,
		const int	dict_id,
		const bool	translate_strings,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const Catalog_Namespace::Catalog *	catalog
	)

Definition at line 794 of file ResultSetIteration.cpp.

References CHECK_EQ, StringDictionaryProxy::getString(), and NULL_INT.

Referenced by build_array_target_value().

                                             {
  std::vector<ScalarTargetValue> values;
  CHECK_EQ(size_t(0), buff_sz % sizeof(int32_t));
  const size_t num_elems = buff_sz / sizeof(int32_t);
  if (translate_strings) {
    for (size_t i = 0; i < num_elems; ++i) {
      const auto string_id = buff[i];

      if (string_id == NULL_INT) {
        values.emplace_back(NullableString(nullptr));
      } else {
        if (dict_id == 0) {
          StringDictionaryProxy* sdp = row_set_mem_owner->getLiteralStringDictProxy();
          values.emplace_back(sdp->getString(string_id));
        } else {
          values.emplace_back(NullableString(
              row_set_mem_owner
                  ->getOrAddStringDictProxy(dict_id, /*with_generation=*/false, catalog)
                  ->getString(string_id)));
        }
      }
    }
  } else {
    for (size_t i = 0; i < num_elems; i++) {
      values.emplace_back(static_cast<int64_t>(buff[i]));
    }
  }
  return ArrayTargetValue(values);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double anonymous_namespace{ResultSetIteration.cpp}::calculate_quantile	(	int8_t const *	ptr,
		double const	q
	)

Definition at line 1852 of file ResultSetIteration.cpp.

References CHECK, and NULL_DOUBLE.

Referenced by ResultSet::getTargetValueFromBufferColwise(), and ResultSet::getTargetValueFromBufferRowwise().

                                                             {
  static_assert(sizeof(int64_t) == sizeof(quantile::TDigest*));
  auto* t_digest = *reinterpret_cast<quantile::TDigest* const*>(ptr);
  CHECK(t_digest) << "ptr=" << (void const*)ptr << ", q=" << q;
  t_digest->mergeBuffer();
  double const median = t_digest->quantile(q);
  return boost::math::isnan(median) ? NULL_DOUBLE : median;
}

Here is the caller graph for this function:

const int8_t* anonymous_namespace{ResultSetIteration.cpp}::columnar_elem_ptr	(	const size_t	entry_idx,
		const int8_t *	col1_ptr,
		const int8_t	compact_sz1
	)

Definition at line 347 of file ResultSetIteration.cpp.

Referenced by ResultSet::ColumnWiseTargetAccessor::getColumnInternal(), and ResultSet::getTargetValueFromBufferColwise().

                                                          {
  return col1_ptr + compact_sz1 * entry_idx;
}

Here is the caller graph for this function:

std::unique_ptr<ArrayDatum> anonymous_namespace{ResultSetIteration.cpp}::fetch_data_from_gpu ( int64_t  varlen_ptr, const int64_t  length, Data_Namespace::DataMgr *  data_mgr, const int  device_id  )

inline

Definition at line 930 of file ResultSetIteration.cpp.

References copy_from_gpu().

Referenced by anonymous_namespace{ResultSetIteration.cpp}::GeoQueryOutputFetchHandler::yieldGpuDatumFetcher().

                                                                            {
  auto cpu_buf = std::shared_ptr<int8_t>(new int8_t[length], FreeDeleter());
  copy_from_gpu(
      data_mgr, cpu_buf.get(), static_cast<CUdeviceptr>(varlen_ptr), length, device_id);
  // Just fetching the data from gpu, not checking geo nullness
  return std::make_unique<ArrayDatum>(length, cpu_buf, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

std::pair<int64_t, int64_t> anonymous_namespace{ResultSetIteration.cpp}::get_frag_id_and_local_idx ( const std::vector< std::vector< T >> &  frag_offsets, const size_t  tab_or_col_idx, const int64_t  global_idx  )

inline

Definition at line 1065 of file ResultSetIteration.cpp.

References CHECK_GE, and CHECK_LT.

Referenced by ResultSet::getColumnFrag().

                              {
  CHECK_GE(global_idx, int64_t(0));
  for (int64_t frag_id = frag_offsets.size() - 1; frag_id > 0; --frag_id) {
    CHECK_LT(tab_or_col_idx, frag_offsets[frag_id].size());
    const auto frag_off = static_cast<int64_t>(frag_offsets[frag_id][tab_or_col_idx]);
    if (frag_off < global_idx) {
      return {frag_id, global_idx - frag_off};
    }
  }
  return {-1, -1};
}

Here is the caller graph for this function:

int64_t anonymous_namespace{ResultSetIteration.cpp}::int_resize_cast	(	const int64_t	ival,
		const size_t	sz
	)

Definition at line 353 of file ResultSetIteration.cpp.

References UNREACHABLE.

Referenced by ResultSet::RowWiseTargetAccessor::getColumnInternal(), ResultSet::ColumnWiseTargetAccessor::getColumnInternal(), and ResultSet::makeTargetValue().

                                                             {
  switch (sz) {
    case 8:
      return ival;
    case 4:
      return static_cast<int32_t>(ival);
    case 2:
      return static_cast<int16_t>(ival);
    case 1:
      return static_cast<int8_t>(ival);
    default:
      UNREACHABLE();
  }
  UNREACHABLE();
  return 0;
}

Here is the caller graph for this function:

std::unique_ptr<ArrayDatum> anonymous_namespace{ResultSetIteration.cpp}::lazy_fetch_chunk ( const int8_t *  ptr, const int64_t  varlen_ptr  )

inline

Definition at line 878 of file ResultSetIteration.cpp.

References CHECK, and ChunkIter_get_nth().

Referenced by anonymous_namespace{ResultSetIteration.cpp}::GeoLazyFetchHandler::fetch().

                                                                              {
  auto ad = std::make_unique<ArrayDatum>();
  bool is_end;
  ChunkIter_get_nth(reinterpret_cast<ChunkIter*>(const_cast<int8_t*>(ptr)),
                    varlen_ptr,
                    ad.get(),
                    &is_end);
  CHECK(!is_end);
  return ad;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TargetValue anonymous_namespace{ResultSetIteration.cpp}::make_avg_target_value	(	const int8_t *	ptr1,
		const int8_t	compact_sz1,
		const int8_t *	ptr2,
		const int8_t	compact_sz2,
		const TargetInfo &	target_info
	)

Definition at line 47 of file ResultSetIteration.cpp.

References TargetInfo::agg_arg_type, TargetInfo::agg_kind, CHECK, kAVG, pair_to_double(), read_int_from_buff(), TargetInfo::sql_type, and takes_float_argument().

Referenced by ResultSet::getTargetValueFromBufferColwise(), and ResultSet::getTargetValueFromBufferRowwise().

                                                                 {
  int64_t sum{0};
  CHECK(target_info.agg_kind == kAVG);
  const bool float_argument_input = takes_float_argument(target_info);
  const auto actual_compact_sz1 = float_argument_input ? sizeof(float) : compact_sz1;
  const auto& agg_ti = target_info.agg_arg_type;
  if (agg_ti.is_integer() || agg_ti.is_decimal()) {
    sum = read_int_from_buff(ptr1, actual_compact_sz1);
  } else if (agg_ti.is_fp()) {
    switch (actual_compact_sz1) {
      case 8: {
        double d = *reinterpret_cast<const double*>(ptr1);
        sum = *reinterpret_cast<const int64_t*>(may_alias_ptr(&d));
        break;
      }
      case 4: {
        double d = *reinterpret_cast<const float*>(ptr1);
        sum = *reinterpret_cast<const int64_t*>(may_alias_ptr(&d));
        break;
      }
      default:
        CHECK(false);
    }
  } else {
    CHECK(false);
  }
  const auto count = read_int_from_buff(ptr2, compact_sz2);
  return pair_to_double({sum, count}, target_info.sql_type, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

size_t anonymous_namespace{ResultSetIteration.cpp}::make_bin_search ( size_t  l, size_t  r, T &&  is_empty_fn  )

inline

Definition at line 2133 of file ResultSetIteration.cpp.

Referenced by ResultSetStorage::binSearchRowCount().

                                                                   {
  // Avoid search if there are no empty keys.
  if (!is_empty_fn(r - 1)) {
    return r;
  }

  --r;
  while (l != r) {
    size_t c = (l + r) / 2;
    if (is_empty_fn(c)) {
      r = c;
    } else {
      l = c + 1;
    }
  }

  return r;
}

Here is the caller graph for this function:

template<class T >

ScalarTargetValue anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv

(

const T

val

)

Definition at line 765 of file ResultSetIteration.cpp.

                                              {
  return ScalarTargetValue(static_cast<int64_t>(val));
}

template<>

ScalarTargetValue anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv

(

const float

val

)

Definition at line 770 of file ResultSetIteration.cpp.

                                                  {
  return ScalarTargetValue(val);
}

template<>

ScalarTargetValue anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv

(

const double

val

)

Definition at line 775 of file ResultSetIteration.cpp.

                                                   {
  return ScalarTargetValue(val);
}

template<class Tuple , size_t... indices>

std::vector<std::pair<const int8_t*, const int64_t> > anonymous_namespace{ResultSetIteration.cpp}::make_vals_vector ( std::index_sequence< indices...>  , const Tuple &  tuple  )

inline

Definition at line 871 of file ResultSetIteration.cpp.

Referenced by anonymous_namespace{ResultSetIteration.cpp}::GeoLazyFetchHandler::fetch().

                        {
  return std::vector<std::pair<const int8_t*, const int64_t>>{
      std::make_pair(std::get<2 * indices>(tuple), std::get<2 * indices + 1>(tuple))...};
}

Here is the caller graph for this function: