17 #ifndef TARGET_VALUE_CONVERTERS_IMPL_H_ 18 #define TARGET_VALUE_CONVERTERS_IMPL_H_ 30 if (std::is_floating_point<T>::value) {
31 return static_cast<T>(inline_fp_null_array_value<T>());
33 return static_cast<T>(inline_int_null_array_value<T>());
37 template <
typename SOURCE_TYPE,
typename RETURN_TYPE,
typename CHECKED_CAST_TYPE>
38 RETURN_TYPE
checked_cast(SOURCE_TYPE val,
bool check_null, RETURN_TYPE null_value) {
39 if (!std::is_same<SOURCE_TYPE, CHECKED_CAST_TYPE>::value) {
42 CHECKED_CAST_TYPE castedVal = boost::numeric_cast<CHECKED_CAST_TYPE>(val);
43 if (check_null && castedVal == null_value) {
44 throw std::runtime_error(
"Overflow or underflow");
47 throw std::runtime_error(
"Overflow or underflow");
51 return static_cast<RETURN_TYPE
>(val);
54 template <
typename SOURCE_TYPE,
typename TARGET_TYPE>
56 using ColumnDataPtr = std::unique_ptr<TARGET_TYPE, CheckedMallocDeleter<TARGET_TYPE>>;
58 using CasterFunc = std::function<TARGET_TYPE(SOURCE_TYPE, bool, TARGET_TYPE)>;
71 TARGET_TYPE nullValue,
72 SOURCE_TYPE nullCheckValue,
75 , null_value_(nullValue)
76 , null_check_value_(nullCheckValue)
77 , do_null_check_(doNullCheck) {
78 fixed_array_null_value_ = get_fixed_array_null_value<TARGET_TYPE>();
92 CHECK(fixed_array_null_value_ != 0);
99 reinterpret_cast<TARGET_TYPE*>(
checked_malloc(num_rows *
sizeof(TARGET_TYPE))));
105 reinterpret_cast<TARGET_TYPE*>(
checked_malloc(num_rows *
sizeof(TARGET_TYPE))));
110 typename ElementsBufferColumnPtr::pointer columnData,
115 if (do_null_check_ && null_check_value_ == val) {
118 if (checked_caster_) {
121 columnData[row] =
static_cast<TARGET_TYPE
>(val);
137 std::unique_ptr<std::vector<std::pair<size_t, ElementsBufferColumnPtr>>>&
139 std::unique_ptr<std::vector<ArrayDatum>>::pointer arrayData) {
140 for (
size_t row = 0; row < array_buffer->size(); row++) {
141 auto& element = (array_buffer->at(row));
143 if (element.second) {
145 int8_t* arrayDataPtr =
reinterpret_cast<int8_t*
>(data.release());
147 ArrayDatum(element.first *
sizeof(TARGET_TYPE), arrayDataPtr, is_null);
154 dataBlock.
numbersPtr =
reinterpret_cast<int8_t*
>(column_data_.get());
155 insertData.
data.push_back(dataBlock);
160 template <
typename TARGET_TYPE>
174 const int32_t buffer_null_sentinal_ = std::numeric_limits<int32_t>::min();
182 int32_t sourceDictId,
185 TARGET_TYPE nullValue,
186 int64_t nullCheckValue,
195 literals_dict_ = literals_dict;
199 source_dict_desc_ =
nullptr;
200 source_dict_proxy_ = source_dict_proxy;
202 use_literals_ = 0 == sourceDictId;
203 if (!use_literals_) {
205 CHECK(source_dict_desc_);
209 auto newId = target_dict_desc_->
stringDict->getOrAdd(entry.second);
210 literals_lookup_[entry.first] = newId;
214 literals_lookup_[buffer_null_sentinal_] = buffer_null_sentinal_;
217 CHECK(target_dict_desc_);
230 return std::make_unique<std::vector<int32_t>>(num_rows);
235 typename ElementsBufferColumnPtr::pointer columnBuffer,
241 (*columnBuffer)[row] = this->buffer_null_sentinal_;
243 (*columnBuffer)[row] = (int32_t)val;
259 if (source_dict_proxy_) {
260 auto str = source_dict_proxy_->
getString(transient_string_id);
261 return source_dict_proxy_->
getOrAdd(str);
263 throw std::runtime_error(
"Unexpected negative source ID");
271 reinterpret_cast<TARGET_TYPE*>(
274 std::vector<int32_t>* bufferPtr =
275 reinterpret_cast<std::vector<int32_t>*
>(buffer.get());
276 TARGET_TYPE* columnDataPtr =
reinterpret_cast<TARGET_TYPE*
>(data.get());
278 for (
size_t i = 0; i < bufferPtr->size(); i++) {
279 auto id = literals_lookup_[(*bufferPtr)[i]];
280 if (
id == buffer_null_sentinal_) {
283 columnDataPtr[i] =
static_cast<TARGET_TYPE
>(id);
290 for (
size_t i = 0; i < bufferPtr->size(); i++) {
291 auto src_id = (*bufferPtr)[i];
292 if (src_id == buffer_null_sentinal_) {
294 }
else if (src_id < 0) {
295 columnDataPtr[i] = convertTransientStringIdToPermanentId(src_id);
297 columnDataPtr[i] =
static_cast<TARGET_TYPE
>(src_id);
302 std::vector<int32_t> dest_ids;
303 dest_ids.resize(bufferPtr->size());
305 if (source_dict_proxy_) {
320 for (
size_t i = 0; i < dest_ids.size(); i++) {
321 auto id = dest_ids[i];
322 if (
id == buffer_null_sentinal_) {
325 if (std::is_signed<TARGET_TYPE>::value) {
327 throw std::runtime_error(
328 "Maximum number of unique strings (" +
330 ") reached in target dictionary");
333 if (
id >= std::numeric_limits<TARGET_TYPE>::max()) {
334 throw std::runtime_error(
335 "Maximum number of unique strings (" +
337 ") reached in target column's dict encoding");
340 columnDataPtr[i] =
static_cast<TARGET_TYPE
>(id);
350 std::unique_ptr<std::vector<std::pair<size_t, ElementsBufferColumnPtr>>>&
352 std::unique_ptr<std::vector<ArrayDatum>>::pointer arrayData) {
354 for (
size_t row = 0; row < array_buffer->size(); row++) {
355 auto& element = (array_buffer->at(row));
357 if (element.second) {
359 processBuffer(std::move(element.second));
360 int8_t* arrayDataPtr =
reinterpret_cast<int8_t*
>(data.release());
362 ArrayDatum(element.first *
sizeof(TARGET_TYPE), arrayDataPtr, is_null);
366 std::vector<std::vector<int32_t>> srcArrayIds(array_buffer->size());
367 std::vector<std::vector<int32_t>> destArrayIds(0);
369 for (
size_t row = 0; row < array_buffer->size(); row++) {
370 auto& element = (array_buffer->at(row));
371 if (element.second) {
372 srcArrayIds[row] = *(element.second.get());
381 for (
size_t row = 0; row < array_buffer->size(); row++) {
382 auto& element = (array_buffer->at(row));
384 if (element.second) {
385 *(element.second.get()) = destArrayIds[row];
386 int8_t* arrayDataPtr =
reinterpret_cast<int8_t*
>(&(element.second->at(0)));
387 (*arrayData)[row] =
ArrayDatum(element.first *
sizeof(TARGET_TYPE),
397 if (column_buffer_) {
398 this->
column_data_ = processBuffer(std::move(column_buffer_));
399 column_buffer_ =
nullptr;
407 insertData.
data.push_back(dataBlock);
425 int32_t sourceDictId,
428 source_dict_ =
nullptr;
429 literals_source_dict_ =
nullptr;
430 dict_encoded_ = dictEncoded;
432 if (0 != sourceDictId) {
434 CHECK(source_dict_desc);
435 source_dict_ = source_dict_desc->stringDict.get();
438 literals_source_dict_ = literals_dict;
450 column_data_ = std::make_unique<std::vector<std::string>>(num_rows);
459 if (std::numeric_limits<int32_t>::min() == val) {
460 (*column_data_)[row] = std::string(
"");
463 std::string strVal = source_dict_->
getString(val);
464 (*column_data_)[row] = strVal;
465 }
else if (literals_source_dict_) {
466 std::string strVal = literals_source_dict_->
getString(val);
467 (*column_data_)[row] = strVal;
469 CHECK_EQ(val, inline_int_null_value<int32_t>());
470 std::string nullStr =
"";
471 (*column_data_)[row] = nullStr;
480 const auto db_str_p = checked_get<std::string>(row, db_p,
STRING_ACCESSOR);
482 if (
nullptr != db_str_p) {
483 (*column_data_)[row] = *db_str_p;
485 (*column_data_)[row] = std::string(
"");
491 convertToColumnarFormatFromDict(row, value);
493 convertToColumnarFormatFromString(row, value);
500 insertData.
data.push_back(dataBlock);
505 template <
typename ELEMENT_CONVERTER>
508 std::vector<std::pair<size_t, typename ELEMENT_CONVERTER::ElementsBufferColumnPtr>>>
514 bool data_finalized_ =
false;
523 std::unique_ptr<ELEMENT_CONVERTER> element_converter,
526 , element_converter_(
std::move(element_converter))
527 , element_type_info_(cd->columnType.get_elem_type())
528 , do_check_null_(do_check_null) {
535 fixed_array_elements_count_ =
536 fixed_array_size_ /
sizeof(ELEMENT_CONVERTER::fixed_array_null_value_);
537 element_converter_->populateFixedArrayNullSentinel(fixed_array_elements_count_);
538 fixed_array_null_sentinel_ =
539 reinterpret_cast<int8_t*
>(element_converter_->column_data_.get());
541 fixed_array_size_ = 0;
542 fixed_array_elements_count_ = 0;
543 fixed_array_null_sentinel_ =
nullptr;
551 column_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
552 column_buffer_ = std::make_unique<std::vector<
553 std::pair<size_t, typename ELEMENT_CONVERTER::ElementsBufferColumnPtr>>>(
558 const auto arrayValue =
559 checked_get<ArrayTargetValue>(row, value, ARRAY_VALUE_ACCESSOR);
561 if (arrayValue->is_initialized()) {
562 const auto& vec = arrayValue->get();
565 if (fixed_array_elements_count_) {
566 if (fixed_array_elements_count_ != vec.size()) {
567 throw std::runtime_error(
568 "Incorrect number of array elements for fixed length array column");
573 typename ELEMENT_CONVERTER::ElementsBufferColumnPtr elementBuffer =
574 element_converter_->allocateColumnarBuffer(vec.size());
576 int elementIndex = 0;
577 for (
const auto& scalarValue : vec) {
578 element_converter_->convertElementToColumnarFormat(
579 elementIndex++, elementBuffer.get(), &scalarValue);
582 column_buffer_->at(row) = {vec.size(), std::move(elementBuffer)};
589 if (!do_check_null_) {
590 throw std::runtime_error(
"NULL assignment of non null column not allowed");
593 if (fixed_array_elements_count_ && !element_converter_->allowFixedNullArray()) {
594 throw std::runtime_error(
"NULL assignment of fixed length array not allowed");
599 fixed_array_size_, fixed_array_null_sentinel_, is_null,
DoNothingDeleter());
600 (*column_data_)[row].is_null =
is_null;
605 if (!data_finalized_) {
606 element_converter_->processArrayBuffer(column_buffer_, column_data_.get());
607 data_finalized_ =
true;
614 dataBlock.
arraysPtr = column_data_.get();
615 insertData.
data.push_back(dataBlock);
632 CHECK(coords_column_descriptor_);
643 column_data_ = std::make_unique<std::vector<std::string>>(num_rows);
644 signed_compressed_coords_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
651 const std::shared_ptr<std::vector<double>>& coords) {
652 const auto compressed_coords_vector =
655 uint8_t* compressed_coords_array =
reinterpret_cast<uint8_t*
>(
656 checked_malloc(
sizeof(uint8_t) * compressed_coords_vector.size()));
657 memcpy(compressed_coords_array,
658 &compressed_coords_vector[0],
659 compressed_coords_vector.size());
661 return ArrayDatum((
int)compressed_coords_vector.size(),
662 reinterpret_cast<int8_t*
>(compressed_coords_array),
667 const auto geoValue = checked_get<GeoTargetValue>(row, value, GEO_VALUE_ACCESSOR);
669 if (geoValue->is_initialized()) {
670 const auto geo = geoValue->get();
671 const auto geoPoint =
672 checked_get<GeoPointTargetValue>(row, &geo, GEO_POINT_VALUE_ACCESSOR);
674 (*column_data_)[row] =
"";
675 (*signed_compressed_coords_data_)[row] = toCompressedCoords(geoPoint->coords);
678 (*column_data_)[row] =
"";
680 auto coords_datum = toCompressedCoords(coords);
681 coords_datum.is_null =
true;
682 (*signed_compressed_coords_data_)[row] = coords_datum;
690 coords.
arraysPtr = signed_compressed_coords_data_.get();
692 insertData.
data.emplace_back(logical);
695 insertData.
data.emplace_back(coords);
701 const std::shared_ptr<std::vector<double>>& coords) {
702 std::vector<double> bounds(4);
703 constexpr
auto DOUBLE_MAX = std::numeric_limits<double>::max();
704 constexpr
auto DOUBLE_MIN = std::numeric_limits<double>::lowest();
709 auto size_coords = coords->size();
711 for (
size_t i = 0; i < size_coords; i += 2) {
712 double x = (*coords)[i];
713 double y = (*coords)[i + 1];
715 bounds[0] = std::min(bounds[0], x);
716 bounds[1] = std::min(bounds[1], y);
717 bounds[2] = std::max(bounds[2], x);
718 bounds[3] = std::max(bounds[3], y);
723 template <
typename ELEM_TYPE>
726 reinterpret_cast<ELEM_TYPE*
>(
checked_malloc(
sizeof(ELEM_TYPE) * vector.size()));
727 memcpy(array, vector.data(), vector.size() *
sizeof(ELEM_TYPE));
730 (
int)(vector.size() *
sizeof(ELEM_TYPE)),
reinterpret_cast<int8_t*
>(array),
false);
733 template <
typename ELEM_TYPE>
749 CHECK(bounds_column_descriptor_);
761 bounds_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
767 const auto geoValue =
770 if (geoValue->is_initialized()) {
771 const auto geo = geoValue->get();
772 const auto geoLinestring =
773 checked_get<GeoLineStringTargetValue>(row, &geo, GEO_LINESTRING_VALUE_ACCESSOR);
775 (*column_data_)[row] =
"";
776 (*signed_compressed_coords_data_)[row] = toCompressedCoords(geoLinestring->coords);
781 (*column_data_)[row] =
"";
782 (*signed_compressed_coords_data_)[row] =
ArrayDatum(0,
nullptr,
true);
783 std::vector<double> bounds = {
786 bounds_datum.is_null =
true;
787 (*bounds_data_)[row] = bounds_datum;
798 insertData.
data.emplace_back(bounds);
819 CHECK(ring_sizes_column_descriptor_);
822 CHECK(bounds_column_descriptor_);
825 CHECK(render_group_column_descriptor_);
836 ring_sizes_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
837 bounds_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
838 render_group_data_ = std::make_unique<int32_t[]>(num_rows);
844 const auto geoValue =
847 if (geoValue->is_initialized()) {
848 const auto geo = geoValue->get();
850 checked_get<GeoPolyTargetValue>(row, &geo, GEO_POLY_VALUE_ACCESSOR);
852 (*column_data_)[row] =
"";
853 (*signed_compressed_coords_data_)[row] = toCompressedCoords(geoPoly->coords);
857 render_group_data_[row] =
861 (*column_data_)[row] =
"";
862 (*signed_compressed_coords_data_)[row] =
ArrayDatum(0,
nullptr,
true);
863 (*ring_sizes_data_)[row] =
ArrayDatum(0,
nullptr,
true);
864 std::vector<double> bounds = {
867 bounds_datum.is_null =
true;
868 (*bounds_data_)[row] = bounds_datum;
878 ringSizes.
arraysPtr = ring_sizes_data_.get();
880 renderGroup.
numbersPtr =
reinterpret_cast<int8_t*
>(render_group_data_.get());
882 insertData.
data.emplace_back(ringSizes);
885 insertData.
data.emplace_back(bounds);
888 insertData.
data.emplace_back(renderGroup);
911 CHECK(ring_sizes_column_descriptor_);
914 CHECK(ring_sizes_column_descriptor_);
917 CHECK(bounds_column_descriptor_);
920 CHECK(render_group_column_descriptor_);
931 ring_sizes_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
932 poly_rings_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
933 bounds_data_ = std::make_unique<std::vector<ArrayDatum>>(num_rows);
934 render_group_data_ = std::make_unique<int32_t[]>(num_rows);
940 const auto geoValue =
943 if (geoValue->is_initialized()) {
944 const auto geo = geoValue->get();
945 const auto geoMultiPoly =
946 checked_get<GeoMultiPolyTargetValue>(row, &geo, GEO_MULTI_POLY_VALUE_ACCESSOR);
948 (*column_data_)[row] =
"";
949 (*signed_compressed_coords_data_)[row] = toCompressedCoords(geoMultiPoly->coords);
950 (*ring_sizes_data_)[row] =
to_array_datum(geoMultiPoly->ring_sizes);
951 (*poly_rings_data_)[row] =
to_array_datum(geoMultiPoly->poly_rings);
954 render_group_data_[row] =
958 (*column_data_)[row] =
"";
959 (*signed_compressed_coords_data_)[row] =
ArrayDatum(0,
nullptr,
true);
960 (*ring_sizes_data_)[row] =
ArrayDatum(0,
nullptr,
true);
961 (*poly_rings_data_)[row] =
ArrayDatum(0,
nullptr,
true);
962 std::vector<double> bounds = {
965 bounds_datum.is_null =
true;
966 (*bounds_data_)[row] = bounds_datum;
976 ringSizes.
arraysPtr = ring_sizes_data_.get();
977 polyRings.
arraysPtr = poly_rings_data_.get();
979 renderGroup.
numbersPtr =
reinterpret_cast<int8_t*
>(render_group_data_.get());
981 insertData.
data.emplace_back(ringSizes);
984 insertData.
data.emplace_back(polyRings);
987 insertData.
data.emplace_back(bounds);
990 insertData.
data.emplace_back(renderGroup);
std::unique_ptr< std::vector< ArrayDatum > > ring_sizes_data_
TARGET_TYPE fixed_array_null_value_
ArrayDatum to_array_datum(const std::vector< ELEM_TYPE > &vector)
std::unique_ptr< std::vector< ArrayDatum > > bounds_data_
StringDictionaryProxy * literals_source_dict_
void convertToColumnarFormatFromDict(size_t row, const TargetValue *value)
void allocateColumnarData(size_t num_rows) override
std::unique_ptr< std::vector< ArrayDatum > > bounds_data_
~StringValueConverter() override
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
class for a per-database catalog. also includes metadata for the current database and the current use...
std::vector< std::string > * stringsPtr
const ColumnDescriptor * ring_sizes_solumn_descriptor_
std::vector< ArrayDatum > * arraysPtr
size_t fixed_array_elements_count_
import_export::RenderGroupAnalyzer render_group_analyzer_
std::unique_ptr< int32_t[]> render_group_data_
std::vector< uint8_t > compress_coords(std::vector< double > &coords, const SQLTypeInfo &ti)
constexpr auto DOUBLE_MAX
void allocateColumnarData(size_t num_rows) override
~GeoPolygonValueConverter() override
void processArrayBuffer(std::unique_ptr< std::vector< std::pair< size_t, ElementsBufferColumnPtr >>> &array_buffer, std::unique_ptr< std::vector< ArrayDatum >>::pointer arrayData)
boost_variant_accessor< int64_t > SOURCE_TYPE_ACCESSOR
const ColumnDescriptor * bounds_column_descriptor_
ArrayValueConverter(const ColumnDescriptor *cd, size_t num_rows, std::unique_ptr< ELEMENT_CONVERTER > element_converter, bool do_check_null)
~NumericValueConverter() override
bool allowFixedNullArray()
std::string getString(int32_t string_id) const
void populateFixedArrayNullSentinel(size_t num_rows)
const DictDescriptor * source_dict_desc_
HOST DEVICE int get_comp_param() const
SQLTypeInfo element_type_info_
void convertToColumnarFormat(size_t row, const TargetValue *value) override
void convertToColumnarFormat(size_t row, const ScalarTargetValue *scalarValue)
std::unique_ptr< std::vector< ArrayDatum > > bounds_data_
void allocateColumnarData(size_t num_rows) override
HOST DEVICE int get_size() const
const ColumnDescriptor * column_descriptor_
CasterFunc checked_caster_
~DictionaryValueConverter() override
const ColumnDescriptor * getMetadataForColumn(int tableId, const std::string &colName) const
ArrayDatum toCompressedCoords(const std::shared_ptr< std::vector< double >> &coords)
static void populate_string_ids(std::vector< int32_t > &dest_ids, StringDictionary *dest_dict, const std::vector< int32_t > &source_ids, const StringDictionary *source_dict, const std::map< int32_t, std::string > transient_mapping={})
Populates provided dest_ids vector with string ids corresponding to given source strings.
ElementsBufferColumnPtr column_buffer_
std::vector< double > compute_bounds_of_coords(const std::shared_ptr< std::vector< double >> &coords)
std::unique_ptr< std::vector< ArrayDatum > > poly_rings_data_
void processArrayBuffer(std::unique_ptr< std::vector< std::pair< size_t, ElementsBufferColumnPtr >>> &array_buffer, std::unique_ptr< std::vector< ArrayDatum >>::pointer arrayData)
std::function< TARGET_TYPE(int64_t, bool, TARGET_TYPE)> CasterFunc
ElementsBufferColumnPtr allocateColumnarBuffer(size_t num_rows)
~ArrayValueConverter() override
void convertElementToColumnarFormat(size_t row, typename ElementsBufferColumnPtr::pointer columnData, const ScalarTargetValue *scalarValue)
const DictDescriptor * target_dict_desc_
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
const StringDictionaryProxy * literals_dict_
void convertToColumnarFormat(size_t row, const ScalarTargetValue *scalarValue)
std::shared_ptr< StringDictionary > stringDict
boost_variant_accessor< ScalarTargetValue > SCALAR_TARGET_VALUE_ACCESSOR
boost_variant_accessor< GeoLineStringTargetValue > GEO_LINESTRING_VALUE_ACCESSOR
std::conditional_t< is_cuda_compiler(), DeviceArrayDatum, HostArrayDatum > ArrayDatum
GeoPointValueConverter(const Catalog_Namespace::Catalog &cat, size_t num_rows, const ColumnDescriptor *logicalColumnDescriptor)
const std::map< int32_t, std::string > getTransientMapping() const
boost_variant_accessor< NullableString > NULLABLE_STRING_ACCESSOR
std::unique_ptr< std::vector< std::string > > column_data_
CONSTEXPR DEVICE bool is_null(const T &value)
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
virtual void finalizeDataBlocksForInsertData()
std::string getString(int32_t string_id) const
bool allowFixedNullArray()
void convertToColumnarFormatFromString(size_t row, const TargetValue *value)
void * checked_malloc(const size_t size)
boost_variant_accessor< GeoMultiPolyTargetValue > GEO_MULTI_POLY_VALUE_ACCESSOR
const ColumnDescriptor * bounds_column_descriptor_
boost_variant_accessor< GeoPolyTargetValue > GEO_POLY_VALUE_ACCESSOR
boost_variant_accessor< std::string > STRING_ACCESSOR
const ColumnDescriptor * ring_sizes_column_descriptor_
std::unique_ptr< std::vector< ArrayDatum > > ring_sizes_data_
void finalizeDataBlocksForInsertData() override
GeoLinestringValueConverter(const Catalog_Namespace::Catalog &cat, size_t num_rows, const ColumnDescriptor *logicalColumnDescriptor)
specifies the content in-memory of a row in the column metadata table
GeoMultiPolygonValueConverter(const Catalog_Namespace::Catalog &cat, size_t num_rows, const ColumnDescriptor *logicalColumnDescriptor)
void convertToColumnarFormat(size_t row, const TargetValue *value) override
const DictDescriptor * getMetadataForDict(int dict_ref, bool loadDict=true) const
std::unique_ptr< ELEMENT_CONVERTER > element_converter_
T get_fixed_array_null_value()
void convertToColumnarFormat(size_t row, const TargetValue *value) override
std::unique_ptr< int32_t[]> render_group_data_
StringValueConverter(const Catalog_Namespace::Catalog &cat, const ColumnDescriptor *cd, size_t num_rows, bool dictEncoded, int32_t sourceDictId, StringDictionaryProxy *literals_dict)
void finalizeDataBlocksForInsertData() override
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
void setValueCaster(CasterFunc caster)
std::vector< DataBlockPtr > data
the number of rows being inserted
int32_t getOrAdd(const std::string &str) noexcept
void allocateColumnarData(size_t num_rows) override
int32_t convertTransientStringIdToPermanentId(int32_t &transient_string_id)
void convertToColumnarFormat(size_t row, const TargetValue *value) override
~GeoLinestringValueConverter() override
std::unique_ptr< std::vector< std::string > > column_data_
const ColumnDescriptor * render_group_column_descriptor_
typename NumericValueConverter< int64_t, TARGET_TYPE >::ColumnDataPtr ElementsDataColumnPtr
ColumnDataPtr ElementsBufferColumnPtr
std::unordered_map< int32_t, int32_t > literals_lookup_
RETURN_TYPE checked_cast(SOURCE_TYPE val, bool check_null, RETURN_TYPE null_value)
const ColumnDescriptor * coords_column_descriptor_
void allocateColumnarData(size_t num_rows) override
constexpr auto DOUBLE_MIN
void allocateColumnarData(size_t num_rows) override
boost_variant_accessor< GeoTargetValue > GEO_VALUE_ACCESSOR
ColumnDataPtr column_data_
#define NULL_ARRAY_DOUBLE
const ColumnDescriptor * render_group_column_descriptor_
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
static void populate_string_array_ids(std::vector< std::vector< int32_t >> &dest_array_ids, StringDictionary *dest_dict, const std::vector< std::vector< int32_t >> &source_array_ids, const StringDictionary *source_dict)
NumericValueConverter< int64_t, TARGET_TYPE >::ColumnDataPtr processBuffer(ElementsBufferColumnPtr buffer)
std::unique_ptr< std::vector< std::pair< size_t, typename ELEMENT_CONVERTER::ElementsBufferColumnPtr > > > column_buffer_
boost_variant_accessor< GeoTargetValue > GEO_TARGET_VALUE_ACCESSOR
Descriptor for a dictionary for a string columne.
const ColumnDescriptor * bounds_column_descriptor_
void convertToColumnarFormat(size_t row, const TargetValue *value) override
~GeoMultiPolygonValueConverter() override
void convertToColumnarFormat(size_t row, const TargetValue *value) override
The data to be inserted using the fragment manager.
import_export::RenderGroupAnalyzer render_group_analyzer_
std::unique_ptr< std::vector< int32_t > > ElementsBufferColumnPtr
boost::variant< ScalarTargetValue, ArrayTargetValue, GeoTargetValue, GeoTargetValuePtr > TargetValue
std::unique_ptr< std::vector< ArrayDatum > > column_data_
SOURCE_TYPE null_check_value_
void convertElementToColumnarFormat(size_t row, typename ElementsBufferColumnPtr::pointer columnBuffer, const ScalarTargetValue *scalarValue)
void allocateColumnarData(size_t num_rows) override
void convertToColumnarFormat(size_t row, const TargetValue *value) override
ElementsBufferColumnPtr allocateColumnarBuffer(size_t num_rows)
void convertToColumnarFormat(size_t row, const TargetValue *value) override
int8_t * fixed_array_null_sentinel_
boost_variant_accessor< ArrayTargetValue > ARRAY_VALUE_ACCESSOR
boost_variant_accessor< GeoPointTargetValue > GEO_POINT_VALUE_ACCESSOR
const ColumnDescriptor * ring_sizes_column_descriptor_
boost_variant_accessor< SOURCE_TYPE > SOURCE_TYPE_ACCESSOR
std::unique_ptr< TARGET_TYPE, CheckedMallocDeleter< TARGET_TYPE > > ColumnDataPtr
std::vector< int > columnIds
identifies the table into which the data is being inserted
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
~GeoPointValueConverter() override
int insertBoundsAndReturnRenderGroup(const std::vector< double > &bounds)
GeoPolygonValueConverter(const Catalog_Namespace::Catalog &cat, size_t num_rows, const ColumnDescriptor *logicalColumnDescriptor)
StringDictionary * source_dict_
std::unique_ptr< std::vector< ArrayDatum > > signed_compressed_coords_data_
void addDataBlocksToInsertData(Fragmenter_Namespace::InsertData &insertData) override
StringDictionaryProxy * source_dict_proxy_
NumericValueConverter(const ColumnDescriptor *cd, size_t num_rows, TARGET_TYPE nullValue, SOURCE_TYPE nullCheckValue, bool doNullCheck)
DictionaryValueConverter(const Catalog_Namespace::Catalog &cat, int32_t sourceDictId, const ColumnDescriptor *targetDescriptor, size_t num_rows, TARGET_TYPE nullValue, int64_t nullCheckValue, bool doNullCheck, StringDictionaryProxy *literals_dict, StringDictionaryProxy *source_dict_proxy)
boost::variant< int64_t, double, float, NullableString > ScalarTargetValue