ResultSetIteration.cpp File Reference

Iteration part of the row set interface. More...

#include "Execute.h"
#include "Geospatial/Compression.h"
#include "Geospatial/Types.h"
#include "ParserNode.h"
#include "QueryEngine/QueryEngine.h"
#include "QueryEngine/TargetValue.h"
#include "QueryEngine/Utils/FlatBuffer.h"
#include "ResultSet.h"
#include "ResultSetGeoSerialization.h"
#include "RuntimeFunctions.h"
#include "Shared/SqlTypesLayout.h"
#include "Shared/likely.h"
#include "Shared/sqltypes.h"
#include "TypePunning.h"
#include <boost/math/special_functions/fpclassify.hpp>
#include <memory>
#include <utility>

Include dependency graph for ResultSetIteration.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{ResultSetIteration.cpp}::GeoLazyFetchHandler
struct	anonymous_namespace{ResultSetIteration.cpp}::GeoQueryOutputFetchHandler
struct	anonymous_namespace{ResultSetIteration.cpp}::GeoTargetValueBuilder< GEO_SOURCE_TYPE, GeoTargetFetcher >

Namespaces
	anonymous_namespace{ResultSetIteration.cpp}

Macros
#define	DEF_GET_ENTRY_AT(query_type, columnar_output)
#define	DATA_T   int64_t
#define	DATA_T   int32_t
#define	DATA_T   int16_t
#define	DATA_T   int8_t
#define	DATA_T   float
#define	DATA_T   double

Functions
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)
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)
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)
int64_t	anonymous_namespace{ResultSetIteration.cpp}::int_resize_cast (const int64_t ival, const size_t sz)
template<class T >
ScalarTargetValue	anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv (const T val)
template<>
ScalarTargetValue	anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv (const float val)
template<>
ScalarTargetValue	anonymous_namespace{ResultSetIteration.cpp}::make_scalar_tv (const double val)
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)
TargetValue	anonymous_namespace{ResultSetIteration.cpp}::build_string_array_target_value (const int32_t *buff, const size_t buff_sz, const shared::StringDictKey &dict_key, const bool translate_strings, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner)
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)
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)
std::unique_ptr< ArrayDatum >	anonymous_namespace{ResultSetIteration.cpp}::lazy_fetch_chunk (const int8_t *ptr, const int64_t varlen_ptr)
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)
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)
template<size_t NDIM, typename GeospatialGeoType , typename GeoTypeTargetValue , typename GeoTypeTargetValuePtr >
TargetValue	NestedArrayToGeoTargetValue (const int8_t *buf, const int64_t index, const SQLTypeInfo &ti, const ResultSet::GeoReturnType return_type)
TargetValue	getTargetValueFromFlatBuffer (const int8_t *col_ptr, const TargetInfo &target_info, const size_t slot_idx, const size_t target_logical_idx, const size_t global_entry_idx, const size_t local_entry_idx, const bool translate_strings, const std::shared_ptr< RowSetMemoryOwner > &row_set_mem_owner_)
template<typename T >
size_t	anonymous_namespace{ResultSetIteration.cpp}::make_bin_search (size_t l, size_t r, T &&is_empty_fn)

Detailed Description

Iteration part of the row set interface.

Definition in file ResultSetIteration.cpp.

Macro Definition Documentation

#define DATA_T   int64_t

Definition at line 1273 of file ResultSetIteration.cpp.

#define DATA_T   int32_t

Definition at line 1273 of file ResultSetIteration.cpp.

#define DATA_T   int16_t

Definition at line 1273 of file ResultSetIteration.cpp.

#define DATA_T   int8_t

Definition at line 1273 of file ResultSetIteration.cpp.

#define DATA_T   float

Definition at line 1273 of file ResultSetIteration.cpp.

#define DATA_T   double

Definition at line 1273 of file ResultSetIteration.cpp.

#define DEF_GET_ENTRY_AT	(		query_type,
			columnar_output
	)

Value:

template DATA_T ResultSet::getEntryAt<DATA_T, query_type, columnar_output>( \
      const size_t row_idx, const size_t target_idx, const size_t slot_idx) const;

Definition at line 1234 of file ResultSetIteration.cpp.

Function Documentation

TargetValue getTargetValueFromFlatBuffer	(	const int8_t *	col_ptr,
		const TargetInfo &	target_info,
		const size_t	slot_idx,
		const size_t	target_logical_idx,
		const size_t	global_entry_idx,
		const size_t	local_entry_idx,
		const bool	translate_strings,
		const std::shared_ptr< RowSetMemoryOwner > &	row_set_mem_owner_
	)

Definition at line 2214 of file ResultSetIteration.cpp.

References anonymous_namespace{ResultSetIteration.cpp}::build_array_target_value(), CHECK, CHECK_EQ, CHECK_GE, SQLTypeInfo::get_type(), FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::isFlatBuffer(), kARRAY, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, run_benchmark_import::optional, TargetInfo::sql_type, UNREACHABLE, and FlatBufferManager::NestedArrayItem< NDIM >::values.

Referenced by ResultSet::getTargetValueFromBufferColwise().

                                                                {
  CHECK(FlatBufferManager::isFlatBuffer(col_ptr));
  FlatBufferManager m{const_cast<int8_t*>(col_ptr)};
  FlatBufferManager::Status status{};
  CHECK(m.isNestedArray());
  switch (target_info.sql_type.get_type()) {
    case kARRAY: {
      ArrayDatum ad;
      FlatBufferManager::NestedArrayItem<1> item;
      status = m.getItem(local_entry_idx, item);
      if (status == FlatBufferManager::Status::Success) {
        ad.length = item.nof_values * m.getValueSize();
        ad.pointer = item.values;
        ad.is_null = item.is_null;
      } else {
        ad.length = 0;
        ad.pointer = NULL;
        ad.is_null = true;
        CHECK_EQ(status, FlatBufferManager::Status::ItemUnspecifiedError);
      }
      if (ad.is_null) {
        return ArrayTargetValue(boost::optional<std::vector<ScalarTargetValue>>{});
      }
      CHECK_GE(ad.length, 0u);
      if (ad.length > 0) {
        CHECK(ad.pointer);
      }
      return build_array_target_value(target_info.sql_type,
                                      ad.pointer,
                                      ad.length,
                                      translate_strings,
                                      row_set_mem_owner_);
    } break;
    default:
      UNREACHABLE() << "ti=" << target_info.sql_type;
  }
  CHECK(false);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<size_t NDIM, typename GeospatialGeoType , typename GeoTypeTargetValue , typename GeoTypeTargetValuePtr >

TargetValue NestedArrayToGeoTargetValue	(	const int8_t *	buf,
		const int64_t	index,
		const SQLTypeInfo &	ti,
		const ResultSet::GeoReturnType	return_type
	)

Definition at line 1520 of file ResultSetIteration.cpp.

References CHECK_EQ, Geospatial::decompress_coords< double, SQLTypeInfo >(), ResultSet::GeoTargetValue, ResultSet::GeoTargetValueGpuPtr, ResultSet::GeoTargetValuePtr, SQLTypeInfo::get_compression(), SQLTypeInfoLite::is_geoint(), FlatBufferManager::NestedArrayItem< NDIM >::is_null, kENCODING_GEOINT, kENCODING_NONE, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, UNREACHABLE, FlatBufferManager::NestedArrayItem< NDIM >::values, and ResultSet::WktString.

Referenced by ResultSet::makeGeoTargetValue().

                                                                                  {
  FlatBufferManager m{const_cast<int8_t*>(buf)};
  const SQLTypeInfoLite* ti_lite =
      reinterpret_cast<const SQLTypeInfoLite*>(m.get_user_data_buffer());
  if (ti_lite->is_geoint()) {
    CHECK_EQ(ti.get_compression(), kENCODING_GEOINT);
  } else {
    CHECK_EQ(ti.get_compression(), kENCODING_NONE);
  }
  FlatBufferManager::NestedArrayItem<NDIM> item;
  auto status = m.getItem(index, item);
  CHECK_EQ(status, FlatBufferManager::Status::Success);
  if (!item.is_null) {
    // to ensure we can access item.sizes_buffers[...] and item.sizes_lengths[...]
    CHECK_EQ(item.nof_sizes, NDIM - 1);
  }
  switch (return_type) {
    case ResultSet::GeoReturnType::WktString: {
      if (item.is_null) {
        return NullableString(nullptr);
      }
      std::vector<double> coords;
      if (ti_lite->is_geoint()) {
        coords = *decompress_coords<double, SQLTypeInfo>(
            ti, item.values, 2 * item.nof_values * sizeof(int32_t));
      } else {
        const double* values_buf = reinterpret_cast<const double*>(item.values);
        coords.insert(coords.end(), values_buf, values_buf + 2 * item.nof_values);
      }
      if constexpr (NDIM == 1) {
        GeospatialGeoType obj(coords);
        return NullableString(obj.getWktString());
      } else if constexpr (NDIM == 2) {
        std::vector<int32_t> rings;
        rings.insert(rings.end(),
                     item.sizes_buffers[0],
                     item.sizes_buffers[0] + item.sizes_lengths[0]);
        GeospatialGeoType obj(coords, rings);
        return NullableString(obj.getWktString());
      } else if constexpr (NDIM == 3) {
        std::vector<int32_t> rings;
        std::vector<int32_t> poly_rings;
        poly_rings.insert(poly_rings.end(),
                          item.sizes_buffers[0],
                          item.sizes_buffers[0] + item.sizes_lengths[0]);
        rings.insert(rings.end(),
                     item.sizes_buffers[1],
                     item.sizes_buffers[1] + item.sizes_lengths[1]);
        GeospatialGeoType obj(coords, rings, poly_rings);
        return NullableString(obj.getWktString());
      } else {
        UNREACHABLE();
      }
    } break;
    case ResultSet::GeoReturnType::GeoTargetValue: {
      if (item.is_null) {
        return GeoTargetValue();
      }
      std::vector<double> coords;
      if (ti_lite->is_geoint()) {
        coords = *decompress_coords<double, SQLTypeInfo>(
            ti, item.values, 2 * item.nof_values * sizeof(int32_t));
      } else {
        const double* values_buf = reinterpret_cast<const double*>(item.values);
        coords.insert(coords.end(), values_buf, values_buf + 2 * item.nof_values);
      }
      if constexpr (NDIM == 1) {
        return GeoTargetValue(GeoTypeTargetValue(coords));
      } else if constexpr (NDIM == 2) {
        std::vector<int32_t> rings;
        rings.insert(rings.end(),
                     item.sizes_buffers[0],
                     item.sizes_buffers[0] + item.sizes_lengths[0]);
        return GeoTargetValue(GeoTypeTargetValue(coords, rings));
      } else if constexpr (NDIM == 3) {
        std::vector<int32_t> rings;
        std::vector<int32_t> poly_rings;
        poly_rings.insert(poly_rings.end(),
                          item.sizes_buffers[0],
                          item.sizes_buffers[0] + item.sizes_lengths[0]);
        rings.insert(rings.end(),
                     item.sizes_buffers[1],
                     item.sizes_buffers[1] + item.sizes_lengths[1]);
        return GeoTargetValue(GeoTypeTargetValue(coords, rings, poly_rings));
      } else {
        UNREACHABLE();
      }
    } break;
    case ResultSet::GeoReturnType::GeoTargetValuePtr:
    case ResultSet::GeoReturnType::GeoTargetValueGpuPtr: {
      if (item.is_null) {
        return GeoTypeTargetValuePtr();
      }
      auto coords = std::make_shared<VarlenDatum>(
          item.nof_values * m.getValueSize(), item.values, false);

      if constexpr (NDIM == 1) {
        return GeoTypeTargetValuePtr({std::move(coords)});
      } else if constexpr (NDIM == 2) {
        auto rings = std::make_shared<VarlenDatum>(
            item.sizes_lengths[0] * sizeof(int32_t),
            reinterpret_cast<int8_t*>(item.sizes_buffers[0]),
            false);
        return GeoTypeTargetValuePtr({std::move(coords), std::move(rings)});
      } else if constexpr (NDIM == 3) {
        auto poly_rings = std::make_shared<VarlenDatum>(
            item.sizes_lengths[0] * sizeof(int32_t),
            reinterpret_cast<int8_t*>(item.sizes_buffers[0]),
            false);
        auto rings = std::make_shared<VarlenDatum>(
            item.sizes_lengths[1] * sizeof(int32_t),
            reinterpret_cast<int8_t*>(item.sizes_buffers[1]),
            false);
        return GeoTypeTargetValuePtr(
            {std::move(coords), std::move(rings), std::move(poly_rings)});
      } else {
        UNREACHABLE();
      }
    } break;
    default:
      UNREACHABLE();
  }
  return TargetValue(nullptr);
}

Here is the call graph for this function:

Here is the caller graph for this function: