anonymous_namespace{ColumnarResults.cpp} Namespace Reference

Functions
int64_t	fixed_encoding_nullable_val (const int64_t val, const SQLTypeInfo &type_info)
std::vector< size_t >	get_padded_target_sizes (const ResultSet &rows, const std::vector< SQLTypeInfo > &target_types)
int64_t	toBuffer (const TargetValue &col_val, const SQLTypeInfo &type_info, int8_t *buf)
int64_t	countNumberOfValues (const ResultSet &rows, const size_t column_idx)
int64_t	invalid_read_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_float_key_baseline (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_int64_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_int32_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_int16_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_int8_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_float_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)
template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>
int64_t	read_double_func (const ResultSet &rows, const size_t input_buffer_entry_idx, const size_t target_idx, const size_t slot_idx)

Function Documentation

int64_t anonymous_namespace{ColumnarResults.cpp}::countNumberOfValues	(	const ResultSet &	rows,
		const size_t	column_idx
	)

Definition at line 128 of file ColumnarResults.cpp.

References CHECK, and threading_serial::parallel_reduce().

Referenced by ColumnarResults::ColumnarResults().

                                                                            {
  return tbb::parallel_reduce(
      tbb::blocked_range<int64_t>(0, rows.rowCount()),
      static_cast<int64_t>(0),
      [&](tbb::blocked_range<int64_t> r, int64_t running_count) {
        for (int i = r.begin(); i < r.end(); ++i) {
          const auto crt_row = rows.getRowAtNoTranslations(i);
          const auto arr_tv = boost::get<ArrayTargetValue>(&crt_row[column_idx]);
          CHECK(arr_tv);
          if (arr_tv->is_initialized()) {
            const auto& vec = arr_tv->get();
            running_count += vec.size();
          }
        }
        return running_count;
      },
      std::plus<int64_t>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t anonymous_namespace{ColumnarResults.cpp}::fixed_encoding_nullable_val ( const int64_t  val, const SQLTypeInfo &  type_info  )

inline

Definition at line 33 of file ColumnarResults.cpp.

References CHECK, SQLTypeInfo::get_compression(), get_logical_type_info(), inline_fixed_encoding_null_val(), inline_int_null_val(), kENCODING_DICT, kENCODING_FIXED, and kENCODING_NONE.

Referenced by toBuffer(), and ColumnarResults::writeBackCellDirect().

                                                                         {
  if (type_info.get_compression() != kENCODING_NONE) {
    CHECK(type_info.get_compression() == kENCODING_FIXED ||
          type_info.get_compression() == kENCODING_DICT);
    auto logical_ti = get_logical_type_info(type_info);
    if (val == inline_int_null_val(logical_ti)) {
      return inline_fixed_encoding_null_val(type_info);
    }
  }
  return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<size_t> anonymous_namespace{ColumnarResults.cpp}::get_padded_target_sizes	(	const ResultSet &	rows,
		const std::vector< SQLTypeInfo > &	target_types
	)

Definition at line 46 of file ColumnarResults.cpp.

                                                {
  std::vector<size_t> padded_target_sizes;
  // We have to check that the result set is valid as one entry point
  // to columnar results constructs effectively a fake result set.
  // In these cases it should be safe to assume that we can use the type
  // target widths
  if (!rows.hasValidBuffer() ||
      rows.getQueryMemDesc().getColCount() < target_types.size()) {
    for (const auto& target_type : target_types) {
      padded_target_sizes.emplace_back(target_type.get_size());
    }
    return padded_target_sizes;
  }

  // If here we have a valid result set, so use it's QMD padded widths
  const auto col_context = rows.getQueryMemDesc().getColSlotContext();
  for (size_t col_idx = 0; col_idx < target_types.size(); col_idx++) {
    // Lazy fetch columns will have 0 as a padded with, so use the type's
    // logical width for those
    const auto idx = col_context.getSlotsForCol(col_idx).front();
    const size_t padded_slot_width =
        static_cast<size_t>(rows.getPaddedSlotWidthBytes(idx));
    padded_target_sizes.emplace_back(
        padded_slot_width == 0UL ? target_types[col_idx].get_size() : padded_slot_width);
  }
  return padded_target_sizes;
}

int64_t anonymous_namespace{ColumnarResults.cpp}::invalid_read_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1169 of file ColumnarResults.cpp.

References UNREACHABLE.

Referenced by ColumnarResults::initReadFunctions().

                                                 {
  UNREACHABLE() << "Invalid read function used, target should have been skipped.";
  return static_cast<int64_t>(0);
}

Here is the caller graph for this function:

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_double_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1237 of file ColumnarResults.cpp.

                                                {
  auto dval = rows.getEntryAt<double, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
  return *reinterpret_cast<int64_t*>(may_alias_ptr(&dval));
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_float_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1227 of file ColumnarResults.cpp.

                                               {
  auto fval = rows.getEntryAt<float, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
  return *reinterpret_cast<int32_t*>(may_alias_ptr(&fval));
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_float_key_baseline	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1178 of file ColumnarResults.cpp.

                                                       {
  // float keys in baseline hash are written as doubles in the buffer, so
  // the result should properly be casted before being written in the output
  // columns
  auto fval = static_cast<float>(rows.getEntryAt<double, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx));
  return *reinterpret_cast<int32_t*>(may_alias_ptr(&fval));
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_int16_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1209 of file ColumnarResults.cpp.

                                               {
  return rows.getEntryAt<int16_t, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_int32_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1200 of file ColumnarResults.cpp.

                                               {
  return rows.getEntryAt<int32_t, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_int64_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1191 of file ColumnarResults.cpp.

                                               {
  return rows.getEntryAt<int64_t, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
}

template<QueryDescriptionType QUERY_TYPE, bool COLUMNAR_OUTPUT>

int64_t anonymous_namespace{ColumnarResults.cpp}::read_int8_func	(	const ResultSet &	rows,
		const size_t	input_buffer_entry_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)

Definition at line 1218 of file ColumnarResults.cpp.

                                              {
  return rows.getEntryAt<int8_t, QUERY_TYPE, COLUMNAR_OUTPUT>(
      input_buffer_entry_idx, target_idx, slot_idx);
}

int64_t anonymous_namespace{ColumnarResults.cpp}::toBuffer	(	const TargetValue &	col_val,
		const SQLTypeInfo &	type_info,
		int8_t *	buf
	)

Definition at line 76 of file ColumnarResults.cpp.

References CHECK, fixed_encoding_nullable_val(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), SQLTypeInfo::is_array(), SQLTypeInfo::is_fp(), kDOUBLE, kFLOAT, and UNREACHABLE.

Referenced by ColumnarResults::writeBackCell().

                                                                                        {
  if (type_info.is_array()) {
    const auto array_col_val = boost::get<ArrayTargetValue>(&col_val);
    CHECK(array_col_val);
    const auto& vec = array_col_val->get();
    int64_t offset = 0;
    const auto elem_type_info = type_info.get_elem_type();
    for (const auto& item : vec) {
      offset += toBuffer(item, elem_type_info, buf + offset);
    }
    return offset;
  } else if (type_info.is_fp()) {
    const auto scalar_col_val = boost::get<ScalarTargetValue>(&col_val);
    switch (type_info.get_type()) {
      case kFLOAT: {
        auto float_p = boost::get<float>(scalar_col_val);
        *((float*)buf) = static_cast<float>(*float_p);
        return 4;
      }
      case kDOUBLE: {
        auto double_p = boost::get<double>(scalar_col_val);
        *((double*)buf) = static_cast<double>(*double_p);
        return 8;
      }
      default:
        CHECK(false);
    }
  } else {
    const auto scalar_col_val = boost::get<ScalarTargetValue>(&col_val);
    CHECK(scalar_col_val);
    auto i64_p = boost::get<int64_t>(scalar_col_val);
    const auto val = fixed_encoding_nullable_val(*i64_p, type_info);
    switch (type_info.get_size()) {
      case 1:
        *buf = static_cast<int8_t>(val);
        return 1;
      case 2:
        *((int16_t*)buf) = static_cast<int16_t>(val);
        return 2;
      case 4:
        *((int32_t*)buf) = static_cast<int32_t>(val);
        return 4;
      case 8:
        *((int64_t*)buf) = static_cast<int64_t>(val);
        return 8;
      default:
        UNREACHABLE();
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: