#include <ArrayNoneEncoder.h>

Inheritance diagram for ArrayNoneEncoder:

Collaboration diagram for ArrayNoneEncoder:

Public Member Functions
	ArrayNoneEncoder (AbstractBuffer *buffer)

size_t	getNumElemsForBytesInsertData (const std::vector< ArrayDatum > *srcData, const int start_idx, const size_t numAppendElems, const size_t byteLimit, const bool replicating=false)

size_t	getNumElemsForBytesEncodedDataAtIndices (const int8_t *index_data, const std::vector< size_t > &selected_idx, const size_t byte_limit) override

std::shared_ptr< ChunkMetadata >	appendData (int8_t *&src_data, const size_t num_elems_to_append, const SQLTypeInfo &ti, const bool replicating=false, const int64_t offset=-1) override

std::shared_ptr< ChunkMetadata >	appendEncodedDataAtIndices (const int8_t index_data, int8_t data, const std::vector< size_t > &selected_idx) override

std::shared_ptr< ChunkMetadata >	appendEncodedData (const int8_t index_data, int8_t data, const size_t start_idx, const size_t num_elements) override

std::shared_ptr< ChunkMetadata >	appendData (const std::vector< ArrayDatum > *srcData, const int start_idx, const size_t numAppendElems, const bool replicating)

void	getMetadata (const std::shared_ptr< ChunkMetadata > &chunkMetadata) override

std::shared_ptr< ChunkMetadata >	getMetadata (const SQLTypeInfo &ti) override

void	updateStats (const int64_t, const bool) override

void	updateStats (const double, const bool) override

void	updateStats (const int8_t *const src_data, const size_t num_elements) override

void	updateStats (const std::vector< std::string > *const src_data, const size_t start_idx, const size_t num_elements) override

void	updateStats (const std::vector< ArrayDatum > *const src_data, const size_t start_idx, const size_t num_elements) override

void	reduceStats (const Encoder &) override

void	writeMetadata (FILE *f) override

void	readMetadata (FILE *f) override

void	copyMetadata (const Encoder *copyFromEncoder) override

AbstractBuffer *	getIndexBuf () const

bool	resetChunkStats (const ChunkStats &stats) override
	: Reset chunk level stats (min, max, nulls) using new values from the argument. More...

void	resetChunkStats () override

void	setIndexBuffer (AbstractBuffer *buf)

Public Member Functions inherited from Encoder
	Encoder (Data_Namespace::AbstractBuffer *buffer)

virtual	~Encoder ()

virtual void	updateStatsEncoded (const int8_t *const dst_data, const size_t num_elements)

size_t	getNumElems () const

void	setNumElems (const size_t num_elems)

Public Attributes
Datum	elem_min

Datum	elem_max

bool	has_nulls

bool	initialized

Static Public Attributes
static constexpr size_t	DEFAULT_NULL_PADDING_SIZE {8}

Private Member Functions
void	update_elem_stats (const ArrayDatum &array)

std::pair< ArrayOffsetT, ArrayOffsetT >	getArrayOffsetsAtIndex (const int8_t *index_data, size_t index)

size_t	getArrayDatumSizeAtIndex (const int8_t *index_data, size_t index)

ArrayDatum	getArrayDatumAtIndex (const int8_t index_data, int8_t data, size_t index)

Private Attributes
std::mutex	EncoderMutex_

AbstractBuffer *	index_buf

ArrayOffsetT	last_offset

Additional Inherited Members
Static Public Member Functions inherited from Encoder
static Encoder *	Create (Data_Namespace::AbstractBuffer *buffer, const SQLTypeInfo sqlType)

Protected Attributes inherited from Encoder
size_t	num_elems_

Data_Namespace::AbstractBuffer *	buffer_

DecimalOverflowValidator	decimal_overflow_validator_

DateDaysOverflowValidator	date_days_overflow_validator_

Detailed Description

Definition at line 41 of file ArrayNoneEncoder.h.

Constructor & Destructor Documentation

ArrayNoneEncoder::ArrayNoneEncoder ( AbstractBuffer * buffer )

inline

Definition at line 43 of file ArrayNoneEncoder.h.

       : Encoder(buffer)
       , has_nulls(false)
       , initialized(false)
       , index_buf(nullptr)
       , last_offset(-1) {}

Member Function Documentation

std::shared_ptr<ChunkMetadata> ArrayNoneEncoder::appendData	(	int8_t *&	src_data,
		const size_t	num_elems_to_append,
		const SQLTypeInfo &	ti,
		const bool	replicating = `false`,
		const int64_t	offset = `-1`
	)

inlineoverridevirtual

Append data to the chunk buffer backing this encoder.

Parameters

src_data	Source data for the append
num_elems_to_append	Number of elements to append
ti	SQL Type Info for the column TODO(adb): used?
replicating	Pass one value and fill the chunk with it
offset	Write data starting at a given offset. Default is -1 which indicates an append, an offset of 0 rewrites the chunk up to `num_elems_to_append`.

Implements Encoder.

Definition at line 84 of file ArrayNoneEncoder.h.

References UNREACHABLE.

Referenced by Chunk_NS::Chunk::appendData(), appendEncodedData(), and appendEncodedDataAtIndices().

                                                                                 {
     UNREACHABLE();  // should never be called for arrays
     return nullptr;
   }

Here is the caller graph for this function:

std::shared_ptr<ChunkMetadata> ArrayNoneEncoder::appendData	(	const std::vector< ArrayDatum > *	srcData,
		const int	start_idx,
		const size_t	numAppendElems,
		const bool	replicating
	)

inline

Definition at line 118 of file ArrayNoneEncoder.h.

References Data_Namespace::AbstractBuffer::append(), Encoder::buffer_, CHECK, Data_Namespace::CPU_LEVEL, DEFAULT_NULL_PADDING_SIZE, run_benchmark_import::dest, getMetadata(), index_buf, is_null(), Data_Namespace::AbstractBuffer::isDirty(), last_offset, MAX_INPUT_BUF_SIZE, anonymous_namespace{Utm.h}::n, Encoder::num_elems_, Data_Namespace::AbstractBuffer::read(), Data_Namespace::AbstractBuffer::reserve(), Data_Namespace::AbstractBuffer::setDirty(), Data_Namespace::AbstractBuffer::size(), and update_elem_stats().

                                                                     {
     CHECK(index_buf != nullptr);  // index_buf must be set before this.
     size_t append_index_size = numAppendElems * sizeof(ArrayOffsetT);
     if (num_elems_ == 0) {
       append_index_size += sizeof(ArrayOffsetT);  // plus one for the initial offset
     }
     index_buf->reserve(index_buf->size() + append_index_size);
 
     bool first_elem_padded = false;
     ArrayOffsetT initial_offset = 0;
     if (num_elems_ == 0) {
       if ((*srcData)[0].is_null || (*srcData)[0].length <= 1) {
         // Covers following potentially problematic first arrays:
         // (1) NULL array, issue - can't encode a NULL with 0 initial offset
         // otherwise, if first array is not NULL:
         // (2) length=1 array - could be followed by a {}*/NULL, covers tinyint,bool
         // (3) empty array - could be followed by {}*/NULL, or {}*|{x}|{}*|NULL, etc.
         initial_offset = DEFAULT_NULL_PADDING_SIZE;
         first_elem_padded = true;
       }
       index_buf->append((int8_t*)&initial_offset,
                         sizeof(ArrayOffsetT));  // write the initial offset
       last_offset = initial_offset;
     } else {
       // Valid last_offset is never negative
       // always need to read a valid last offset from buffer/disk
       // b/c now due to vacuum "last offset" may go backward and if
       // index chunk was not reloaded last_offset would go way off!
       index_buf->read((int8_t*)&last_offset,
                       sizeof(ArrayOffsetT),
                       index_buf->size() - sizeof(ArrayOffsetT),
                       Data_Namespace::CPU_LEVEL);
       CHECK(last_offset != -1);
       // If the loaded offset is negative it means the last value was a NULL array,
       // convert to a valid last offset
       if (last_offset < 0) {
         last_offset = -last_offset;
       }
     }
     // Need to start data from 8 byte offset if first array encoded is a NULL array
     size_t append_data_size = (first_elem_padded) ? DEFAULT_NULL_PADDING_SIZE : 0;
     for (size_t n = start_idx; n < start_idx + numAppendElems; n++) {
       // NULL arrays don't take any space so don't add to the data size
       if ((*srcData)[replicating ? 0 : n].is_null) {
         continue;
       }
       append_data_size += (*srcData)[replicating ? 0 : n].length;
     }
     buffer_->reserve(buffer_->size() + append_data_size);
 
     size_t inbuf_size = std::min(std::max(append_index_size, append_data_size),
                                  (size_t)MAX_INPUT_BUF_SIZE);
     auto gc_inbuf = std::make_unique<int8_t[]>(inbuf_size);
     auto inbuf = gc_inbuf.get();
     for (size_t num_appended = 0; num_appended < numAppendElems;) {
       ArrayOffsetT* p = (ArrayOffsetT*)inbuf;
       size_t i;
       for (i = 0; num_appended < numAppendElems && i < inbuf_size / sizeof(ArrayOffsetT);
            i++, num_appended++) {
         p[i] =
             last_offset + (*srcData)[replicating ? 0 : num_appended + start_idx].length;
         last_offset = p[i];
         if ((*srcData)[replicating ? 0 : num_appended + start_idx].is_null) {
           // Record array NULLness in the index buffer
           p[i] = -p[i];
         }
       }
       index_buf->append(inbuf, i * sizeof(ArrayOffsetT));
     }
 
     // Pad buffer_ with 8 bytes if first encoded array is a NULL array
     if (first_elem_padded) {
       auto padding_size = DEFAULT_NULL_PADDING_SIZE;
       buffer_->append(inbuf, padding_size);
     }
     for (size_t num_appended = 0; num_appended < numAppendElems;) {
       size_t size = 0;
       for (int i = start_idx + num_appended;
            num_appended < numAppendElems && size < inbuf_size;
            i++, num_appended++) {
         if ((*srcData)[replicating ? 0 : i].is_null) {
           continue;  // NULL arrays don't take up any space in the data buffer
         }
         size_t len = (*srcData)[replicating ? 0 : i].length;
         if (len > inbuf_size) {
           // for large strings, append on its own
           if (size > 0) {
             buffer_->append(inbuf, size);
           }
           size = 0;
           buffer_->append((*srcData)[replicating ? 0 : i].pointer, len);
           num_appended++;
           break;
         } else if (size + len > inbuf_size) {
           break;
         }
         char* dest = (char*)inbuf + size;
         if (len > 0) {
           std::memcpy((void*)dest, (void*)(*srcData)[replicating ? 0 : i].pointer, len);
           size += len;
         }
       }
       if (size > 0) {
         buffer_->append(inbuf, size);
       }
     }
     // make sure buffer_ is flushed even if no new data is appended to it
     // (e.g. empty strings) because the metadata needs to be flushed.
     if (!buffer_->isDirty()) {
       buffer_->setDirty();
     }
 
     // keep Chunk statistics with array elements
     for (size_t n = start_idx; n < start_idx + numAppendElems; n++) {
       update_elem_stats((*srcData)[replicating ? 0 : n]);
     }
     num_elems_ += numAppendElems;
     auto chunk_metadata = std::make_shared<ChunkMetadata>();
     getMetadata(chunk_metadata);
     return chunk_metadata;
   }

Here is the call graph for this function:

std::shared_ptr<ChunkMetadata> ArrayNoneEncoder::appendEncodedData	(	const int8_t *	index_data,
		int8_t *	data,
		const size_t	start_idx,
		const size_t	num_elements
	)

inlineoverridevirtual

Append encoded data to the chunk buffer backing this encoder.

Parameters

index_data	- (optional) the index data of data to append
data	- the data to append
start_idx	- the position to start encoding from in the `data` array
num_elements	- the number of elements to encode from the `data` array

Returns: updated chunk metadata for the chunk buffer backing this encoder

NOTE: index_data must be non-null for varlen encoder types.

Implements Encoder.

Definition at line 105 of file ArrayNoneEncoder.h.

References appendData(), and getArrayDatumAtIndex().

                                                                                        {
     std::vector<ArrayDatum> data_subset;
     data_subset.reserve(num_elements);
     for (size_t count = 0; count < num_elements; ++count) {
       auto current_index = start_idx + count;
       data_subset.emplace_back(getArrayDatumAtIndex(index_data, data, current_index));
     }
     return appendData(&data_subset, 0, num_elements, false);
   }

Here is the call graph for this function:

std::shared_ptr<ChunkMetadata> ArrayNoneEncoder::appendEncodedDataAtIndices	(	const int8_t *	index_data,
		int8_t *	data,
		const std::vector< size_t > &	selected_idx
	)

inlineoverridevirtual

Append selected encoded data to the chunk buffer backing this encoder.

Parameters

index_data	- (optional) the index data of data to append
data	- the data to append
selected_idx	- which indices in the encoded data to append

Returns: updated chunk metadata for the chunk buffer backing this encoder

NOTE: index_data must be non-null for varlen encoder types.

Implements Encoder.

Definition at line 93 of file ArrayNoneEncoder.h.

References appendData(), and getArrayDatumAtIndex().

                                                       {
     std::vector<ArrayDatum> data_subset;
     data_subset.reserve(selected_idx.size());
     for (const auto& offset_index : selected_idx) {
       data_subset.emplace_back(getArrayDatumAtIndex(index_data, data, offset_index));
     }
     return appendData(&data_subset, 0, selected_idx.size(), false);
   }

Here is the call graph for this function:

void ArrayNoneEncoder::copyMetadata ( const Encoder * copyFromEncoder )

inlineoverridevirtual

Implements Encoder.

Definition at line 297 of file ArrayNoneEncoder.h.

References elem_max, elem_min, Encoder::getNumElems(), has_nulls, initialized, and Encoder::num_elems_.

                                                              {
     num_elems_ = copyFromEncoder->getNumElems();
     auto array_encoder = dynamic_cast<const ArrayNoneEncoder*>(copyFromEncoder);
     elem_min = array_encoder->elem_min;
     elem_max = array_encoder->elem_max;
     has_nulls = array_encoder->has_nulls;
     initialized = array_encoder->initialized;
   }

Here is the call graph for this function:

ArrayDatum ArrayNoneEncoder::getArrayDatumAtIndex	(	const int8_t *	index_data,
		int8_t *	data,
		size_t	index
	)

inlineprivate

Definition at line 581 of file ArrayNoneEncoder.h.

References getArrayOffsetsAtIndex(), is_null(), and last_offset.

Referenced by appendEncodedData(), and appendEncodedDataAtIndices().

                                                                                         {
     auto [offset, last_offset] = getArrayOffsetsAtIndex(index_data, index);
     size_t array_byte_size = std::abs(offset) - std::abs(last_offset);
     bool is_null = offset < 0;
     auto current_data = data + std::abs(last_offset);
     return is_null ? ArrayDatum(0, nullptr, true, DoNothingDeleter{})
                    : ArrayDatum(array_byte_size, current_data, false, DoNothingDeleter{});
   }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ArrayNoneEncoder::getArrayDatumSizeAtIndex	(	const int8_t *	index_data,
		size_t	index
	)

inlineprivate

Definition at line 575 of file ArrayNoneEncoder.h.

References getArrayOffsetsAtIndex(), and last_offset.

Referenced by getNumElemsForBytesEncodedDataAtIndices().

                                                                           {
     auto [offset, last_offset] = getArrayOffsetsAtIndex(index_data, index);
     size_t array_byte_size = std::abs(offset) - std::abs(last_offset);
     return array_byte_size;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<ArrayOffsetT, ArrayOffsetT> ArrayNoneEncoder::getArrayOffsetsAtIndex	(	const int8_t *	index_data,
		size_t	index
	)

inlineprivate

Definition at line 566 of file ArrayNoneEncoder.h.

References last_offset.

Referenced by getArrayDatumAtIndex(), and getArrayDatumSizeAtIndex().

                                                                              {
     auto array_offsets = reinterpret_cast<const ArrayOffsetT*>(index_data);
     auto current_index = index + 1;
     auto offset = array_offsets[current_index];
     int64_t last_offset = array_offsets[current_index - 1];
     return {offset, last_offset};
   }

Here is the caller graph for this function:

AbstractBuffer* ArrayNoneEncoder::getIndexBuf ( ) const

inline

Definition at line 306 of file ArrayNoneEncoder.h.

References index_buf.

306 { return index_buf; }

ArrayNoneEncoder::index_buf

AbstractBuffer * index_buf

Definition: ArrayNoneEncoder.h:338

void ArrayNoneEncoder::getMetadata ( const std::shared_ptr< ChunkMetadata > & chunkMetadata )

inlineoverridevirtual

Reimplemented from Encoder.

Definition at line 243 of file ArrayNoneEncoder.h.

References elem_max, elem_min, Encoder::getMetadata(), and has_nulls.

Referenced by appendData().

                                                                                {
     Encoder::getMetadata(chunkMetadata);  // call on parent class
     chunkMetadata->fillChunkStats(elem_min, elem_max, has_nulls);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<ChunkMetadata> ArrayNoneEncoder::getMetadata ( const SQLTypeInfo & ti )

inlineoverridevirtual

Implements Encoder.

Definition at line 249 of file ArrayNoneEncoder.h.

References elem_max, elem_min, and has_nulls.

                                                                            {
     auto chunk_metadata = std::make_shared<ChunkMetadata>(
         ti, 0, 0, ChunkStats{elem_min, elem_max, has_nulls});
     return chunk_metadata;
   }

size_t ArrayNoneEncoder::getNumElemsForBytesEncodedDataAtIndices	(	const int8_t *	index_data,
		const std::vector< size_t > &	selected_idx,
		const size_t	byte_limit
	)

inlineoverridevirtual

Compute the maximum number of variable length encoded elements given a byte limit

Parameters

index_data	- (optional) index data for the encoded type
selected_idx	- which indices in the encoded data to consider
byte_limit	- byte limit that must be respected

Returns: the number of elements

NOTE: optional parameters above may be ignored by the implementation, but may or may not be required depending on the encoder type backing the implementation.

Implements Encoder.

Definition at line 68 of file ArrayNoneEncoder.h.

References getArrayDatumSizeAtIndex().

                                                                                    {
     size_t num_elements = 0;
     size_t data_size = 0;
     for (const auto& offset_index : selected_idx) {
       auto element_size = getArrayDatumSizeAtIndex(index_data, offset_index);
       if (data_size + element_size > byte_limit) {
         break;
       }
       data_size += element_size;
       num_elements++;
     }
     return num_elements;
   }

Here is the call graph for this function:

size_t ArrayNoneEncoder::getNumElemsForBytesInsertData	(	const std::vector< ArrayDatum > *	srcData,
		const int	start_idx,
		const size_t	numAppendElems,
		const size_t	byteLimit,
		const bool	replicating = `false`
	)

inline

Definition at line 50 of file ArrayNoneEncoder.h.

References anonymous_namespace{Utm.h}::n.

Referenced by Chunk_NS::Chunk::getNumElemsForBytesInsertData().

                                                                        {
     size_t dataSize = 0;
 
     size_t n = start_idx;
     for (; n < start_idx + numAppendElems; n++) {
       size_t len = (*srcData)[replicating ? 0 : n].length;
       if (dataSize + len > byteLimit) {
         break;
       }
       dataSize += len;
     }
     return n - start_idx;
   }

Here is the caller graph for this function:

void ArrayNoneEncoder::readMetadata ( FILE * f )

inlineoverridevirtual

Implements Encoder.

Definition at line 288 of file ArrayNoneEncoder.h.

References elem_max, elem_min, has_nulls, initialized, and Encoder::num_elems_.

                                       {
     // assumes pointer is already in right place
     fread((int8_t*)&num_elems_, sizeof(size_t), 1, f);
     fread((int8_t*)&elem_min, sizeof(Datum), 1, f);
     fread((int8_t*)&elem_max, sizeof(Datum), 1, f);
     fread((int8_t*)&has_nulls, sizeof(bool), 1, f);
     fread((int8_t*)&initialized, sizeof(bool), 1, f);
   }

void ArrayNoneEncoder::reduceStats ( const Encoder & )

inlineoverridevirtual

Implements Encoder.

Definition at line 277 of file ArrayNoneEncoder.h.

References CHECK.

277 { CHECK(false); }

CHECK

#define CHECK(condition)

Definition: Logger.h:291

bool ArrayNoneEncoder::resetChunkStats ( const ChunkStats & )

inlineoverridevirtual

: Reset chunk level stats (min, max, nulls) using new values from the argument.

Returns: : True if an update occurred and the chunk needs to be flushed. False otherwise. Default false if metadata update is unsupported. Only reset chunk stats if the incoming stats differ from the current stats.

Reimplemented from Encoder.

Definition at line 308 of file ArrayNoneEncoder.h.

References Encoder::buffer_, DatumEqual(), elem_max, elem_min, SQLTypeInfo::get_elem_type(), Data_Namespace::AbstractBuffer::getSqlType(), ChunkStats::has_nulls, has_nulls, initialized, ChunkStats::max, and ChunkStats::min.

                                                          {
     auto elem_type = buffer_->getSqlType().get_elem_type();
     if (initialized && DatumEqual(elem_min, stats.min, elem_type) &&
         DatumEqual(elem_max, stats.max, elem_type) && has_nulls == stats.has_nulls) {
       return false;
     }
     elem_min = stats.min;
     elem_max = stats.max;
     has_nulls = stats.has_nulls;
     return true;
   }

Here is the call graph for this function:

void ArrayNoneEncoder::resetChunkStats ( )

inlineoverridevirtual

Resets chunk metadata stats to their default values.

Implements Encoder.

Definition at line 320 of file ArrayNoneEncoder.h.

References has_nulls, and initialized.

                                   {
     has_nulls = false;
     initialized = false;
   }

void ArrayNoneEncoder::setIndexBuffer ( AbstractBuffer * buf )

inline

Definition at line 329 of file ArrayNoneEncoder.h.

References EncoderMutex_, and index_buf.

Referenced by Chunk_NS::Chunk::initEncoder().

                                            {
     std::unique_lock<std::mutex> lock(EncoderMutex_);
     index_buf = buf;
   }

Here is the caller graph for this function:

void ArrayNoneEncoder::update_elem_stats ( const ArrayDatum & array )

inlineprivate

Definition at line 341 of file ArrayNoneEncoder.h.

References Datum::bigintval, Datum::boolval, Encoder::buffer_, CHECK_EQ, Datum::doubleval, elem_max, elem_min, Datum::floatval, SQLTypeInfo::get_compression(), SQLTypeInfo::get_subtype(), Data_Namespace::AbstractBuffer::getSqlType(), has_nulls, initialized, Datum::intval, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kENCODING_DICT, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, NULL_TINYINT, Datum::smallintval, Datum::tinyintval, and UNREACHABLE.

Referenced by appendData(), and updateStats().

                                                   {
     if (array.is_null) {
       has_nulls = true;
     }
     switch (buffer_->getSqlType().get_subtype()) {
       case kBOOLEAN: {
         if (!initialized) {
           elem_min.boolval = 1;
           elem_max.boolval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int8_t* bool_array = array.pointer;
         for (size_t i = 0; i < array.length / sizeof(bool); i++) {
           if (bool_array[i] == NULL_BOOLEAN) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.boolval = std::min(elem_min.boolval, bool_array[i]);
             elem_max.boolval = std::max(elem_max.boolval, bool_array[i]);
           } else {
             elem_min.boolval = bool_array[i];
             elem_max.boolval = bool_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kINT: {
         if (!initialized) {
           elem_min.intval = 1;
           elem_max.intval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int32_t* int_array = (int32_t*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(int32_t); i++) {
           if (int_array[i] == NULL_INT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.intval = std::min(elem_min.intval, int_array[i]);
             elem_max.intval = std::max(elem_max.intval, int_array[i]);
           } else {
             elem_min.intval = int_array[i];
             elem_max.intval = int_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kSMALLINT: {
         if (!initialized) {
           elem_min.smallintval = 1;
           elem_max.smallintval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int16_t* int_array = (int16_t*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(int16_t); i++) {
           if (int_array[i] == NULL_SMALLINT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.smallintval = std::min(elem_min.smallintval, int_array[i]);
             elem_max.smallintval = std::max(elem_max.smallintval, int_array[i]);
           } else {
             elem_min.smallintval = int_array[i];
             elem_max.smallintval = int_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kTINYINT: {
         if (!initialized) {
           elem_min.tinyintval = 1;
           elem_max.tinyintval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int8_t* int_array = (int8_t*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(int8_t); i++) {
           if (int_array[i] == NULL_TINYINT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.tinyintval = std::min(elem_min.tinyintval, int_array[i]);
             elem_max.tinyintval = std::max(elem_max.tinyintval, int_array[i]);
           } else {
             elem_min.tinyintval = int_array[i];
             elem_max.tinyintval = int_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kBIGINT:
       case kNUMERIC:
       case kDECIMAL: {
         if (!initialized) {
           elem_min.bigintval = 1;
           elem_max.bigintval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int64_t* int_array = (int64_t*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(int64_t); i++) {
           if (int_array[i] == NULL_BIGINT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.bigintval = std::min(elem_min.bigintval, int_array[i]);
             elem_max.bigintval = std::max(elem_max.bigintval, int_array[i]);
           } else {
             elem_min.bigintval = int_array[i];
             elem_max.bigintval = int_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kFLOAT: {
         if (!initialized) {
           elem_min.floatval = 1.0;
           elem_max.floatval = 0.0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const float* flt_array = (float*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(float); i++) {
           if (flt_array[i] == NULL_FLOAT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.floatval = std::min(elem_min.floatval, flt_array[i]);
             elem_max.floatval = std::max(elem_max.floatval, flt_array[i]);
           } else {
             elem_min.floatval = flt_array[i];
             elem_max.floatval = flt_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kDOUBLE: {
         if (!initialized) {
           elem_min.doubleval = 1.0;
           elem_max.doubleval = 0.0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const double* dbl_array = (double*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(double); i++) {
           if (dbl_array[i] == NULL_DOUBLE) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.doubleval = std::min(elem_min.doubleval, dbl_array[i]);
             elem_max.doubleval = std::max(elem_max.doubleval, dbl_array[i]);
           } else {
             elem_min.doubleval = dbl_array[i];
             elem_max.doubleval = dbl_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kTIME:
       case kTIMESTAMP:
       case kDATE: {
         if (!initialized) {
           elem_min.bigintval = 1;
           elem_max.bigintval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const auto tm_array = reinterpret_cast<int64_t*>(array.pointer);
         for (size_t i = 0; i < array.length / sizeof(int64_t); i++) {
           if (tm_array[i] == NULL_BIGINT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.bigintval = std::min(elem_min.bigintval, tm_array[i]);
             elem_max.bigintval = std::max(elem_max.bigintval, tm_array[i]);
           } else {
             elem_min.bigintval = tm_array[i];
             elem_max.bigintval = tm_array[i];
             initialized = true;
           }
         }
         break;
       }
       case kCHAR:
       case kVARCHAR:
       case kTEXT: {
         CHECK_EQ(buffer_->getSqlType().get_compression(), kENCODING_DICT);
         if (!initialized) {
           elem_min.intval = 1;
           elem_max.intval = 0;
         }
         if (array.is_null || array.length == 0) {
           break;
         }
         const int32_t* int_array = (int32_t*)array.pointer;
         for (size_t i = 0; i < array.length / sizeof(int32_t); i++) {
           if (int_array[i] == NULL_INT) {
             has_nulls = true;
           } else if (initialized) {
             elem_min.intval = std::min(elem_min.intval, int_array[i]);
             elem_max.intval = std::max(elem_max.intval, int_array[i]);
           } else {
             elem_min.intval = int_array[i];
             elem_max.intval = int_array[i];
             initialized = true;
           }
         }
         break;
       }
       default:
         UNREACHABLE();
     }
   };

Here is the call graph for this function:

Here is the caller graph for this function:

void ArrayNoneEncoder::updateStats	(	const int64_t	,
		const bool
	)

inlineoverridevirtual

Implements Encoder.

Definition at line 255 of file ArrayNoneEncoder.h.

References CHECK.

255 { CHECK(false); }

CHECK

#define CHECK(condition)

Definition: Logger.h:291

void ArrayNoneEncoder::updateStats	(	const double	,
		const bool
	)

inlineoverridevirtual

Implements Encoder.

Definition at line 257 of file ArrayNoneEncoder.h.

References CHECK.

257 { CHECK(false); }

CHECK

#define CHECK(condition)

Definition: Logger.h:291

void ArrayNoneEncoder::updateStats	(	const int8_t *const	src_data,
		const size_t	num_elements
	)

inlineoverridevirtual

Update statistics for data without appending.

Parameters

src_data	- the data with which to update statistics
num_elements	- the number of elements to scan in the data

Implements Encoder.

Definition at line 259 of file ArrayNoneEncoder.h.

References CHECK.

                                                                                      {
     CHECK(false);
   }

void ArrayNoneEncoder::updateStats	(	const std::vector< std::string > *const	src_data,
		const size_t	start_idx,
		const size_t	num_elements
	)

inlineoverridevirtual

Update statistics for string data without appending.

Parameters

src_data	- the string data with which to update statistics
start_idx	- the offset into `src_data` to start the update
num_elements	- the number of elements to scan in the string data

Implements Encoder.

Definition at line 263 of file ArrayNoneEncoder.h.

References UNREACHABLE.

                                                        {
     UNREACHABLE();
   }

void ArrayNoneEncoder::updateStats	(	const std::vector< ArrayDatum > *const	src_data,
		const size_t	start_idx,
		const size_t	num_elements
	)

inlineoverridevirtual

Update statistics for array data without appending.

Parameters

src_data	- the array data with which to update statistics
start_idx	- the offset into `src_data` to start the update
num_elements	- the number of elements to scan in the array data

Implements Encoder.

Definition at line 269 of file ArrayNoneEncoder.h.

References anonymous_namespace{Utm.h}::n, and update_elem_stats().

                                                        {
     for (size_t n = start_idx; n < start_idx + num_elements; n++) {
       update_elem_stats((*src_data)[n]);
     }
   }

Here is the call graph for this function:

void ArrayNoneEncoder::writeMetadata ( FILE * f )

inlineoverridevirtual

Implements Encoder.

Definition at line 279 of file ArrayNoneEncoder.h.

References elem_max, elem_min, has_nulls, initialized, and Encoder::num_elems_.

                                        {
     // assumes pointer is already in right place
     fwrite((int8_t*)&num_elems_, sizeof(size_t), 1, f);
     fwrite((int8_t*)&elem_min, sizeof(Datum), 1, f);
     fwrite((int8_t*)&elem_max, sizeof(Datum), 1, f);
     fwrite((int8_t*)&has_nulls, sizeof(bool), 1, f);
     fwrite((int8_t*)&initialized, sizeof(bool), 1, f);
   }