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	computeTotalNofValuesForColumnArray (const ResultSet &rows, const size_t column_idx)
template<typename TargetValue , typename TargetValuePtr >
int64_t	computeTotalNofValuesForColumnGeoType (const ResultSet &rows, const SQLTypeInfo &ti, const size_t column_idx)
int64_t	computeTotalNofValuesForColumnTextEncodingNone (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}::computeTotalNofValuesForColumnArray	(	const ResultSet &	rows,
		const size_t	column_idx
	)

Definition at line 148 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.entryCount()),
      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);
          if (crt_row.empty()) {
            continue;
          }
          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:

template<typename TargetValue , typename TargetValuePtr >

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

Definition at line 172 of file ColumnarResults.cpp.

References CHECK, SQLTypeInfo::get_compression(), kENCODING_GEOINT, VarlenDatum::length, threading_serial::parallel_reduce(), and UNREACHABLE.

Referenced by ColumnarResults::ColumnarResults().

                                                                       {
  return tbb::parallel_reduce(
      tbb::blocked_range<int64_t>(0, rows.entryCount()),
      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);
          if (crt_row.empty()) {
            continue;
          }
          if (const auto tv = boost::get<ScalarTargetValue>(&crt_row[column_idx])) {
            const auto ns = boost::get<NullableString>(tv);
            CHECK(ns);
            const auto s_ptr = boost::get<std::string>(ns);
            if (s_ptr) {
              // We count the number of commas in WKT representation
              // (e.g. POLYGON ((0 0,4 0,4 4,0 4,0 0),(1 1,1 2,2 2,2
              // 1,1 1))) to get the number of points it contains.
              // This method is usable for any geo type.
              running_count += std::count(s_ptr->begin(), s_ptr->end(), ',') + 1;
            }
          } else if (const auto tv =
                         boost::get<GeoTargetValuePtr>(&crt_row[column_idx])) {
            const auto s = boost::get<TargetValuePtr>(tv);
            CHECK(s);
            VarlenDatum* d = s->coords_data.get();
            if (d != nullptr) {
              running_count +=
                  d->length /
                  (ti.get_compression() == kENCODING_GEOINT ? sizeof(int32_t)
                                                            : sizeof(double)) /
                  2;
            }  // else s is NULL
          } else if (const auto tv = boost::get<GeoTargetValue>(&crt_row[column_idx])) {
            if (tv->get_ptr() != nullptr) {
              const auto s = boost::get<TargetValue>(tv->get());
              std::vector<double>* d = s.coords.get();
              CHECK(d);
              running_count += d->size();
            }  // else s is NULL
          } else {
            UNREACHABLE();
          }
        }
        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}::computeTotalNofValuesForColumnTextEncodingNone	(	const ResultSet &	rows,
		const size_t	column_idx
	)

Definition at line 223 of file ColumnarResults.cpp.

References CHECK, threading_serial::parallel_reduce(), and UNREACHABLE.

Referenced by ColumnarResults::ColumnarResults().

                                                                                {
  return tbb::parallel_reduce(
      tbb::blocked_range<int64_t>(0, rows.entryCount()),
      static_cast<int64_t>(0),
      [&](tbb::blocked_range<int64_t> r, int64_t running_count) {
        for (int i = r.begin(); i < r.end(); ++i) {
          // Apparently, ResultSet permutation vector may be sparse
          // (len(permutation) > entryCount), so we cannot ignore the
          // permutation vector when iterating over all entries.
          const auto crt_row = rows.getRowAtNoTranslations(i);
          if (crt_row.empty()) {
            continue;
          }
          const auto col_val = crt_row[column_idx];
          if (const auto tv = boost::get<ScalarTargetValue>(&col_val)) {
            const auto ns = boost::get<NullableString>(tv);
            CHECK(ns);
            const auto s_ptr = boost::get<std::string>(ns);
            if (s_ptr) {
              running_count += s_ptr->size();
            }
          } else {
            UNREACHABLE();
          }
        }
        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 35 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 48 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 1733 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 1801 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 1791 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 1742 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 1773 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 1764 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 1755 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 1782 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 78 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(), SQLTypeInfo::is_geometry(), kDOUBLE, kFLOAT, and UNREACHABLE.

Referenced by ColumnarResults::writeBackCell().

                                                                                        {
  CHECK(!type_info.is_geometry());
  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:
        UNREACHABLE();
    }
  } 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: