OmniSciDB  fe05a0c208
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ArrayNoneEncoder Class Reference

#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)
 
std::shared_ptr< ChunkMetadataappendData (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< ChunkMetadataappendData (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< ChunkMetadatagetMetadata (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
 
AbstractBuffergetIndexBuf () 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)
 

Private Attributes

std::mutex EncoderMutex_
 
AbstractBufferindex_buf
 
ArrayOffsetT last_offset
 

Additional Inherited Members

- Static Public Member Functions inherited from Encoder
static EncoderCreate (Data_Namespace::AbstractBuffer *buffer, const SQLTypeInfo sqlType)
 
- Protected Attributes inherited from Encoder
size_t num_elems_
 
Data_Namespace::AbstractBufferbuffer_
 
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.

44  : Encoder(buffer)
45  , has_nulls(false)
46  , initialized(false)
47  , index_buf(nullptr)
48  , last_offset(-1) {}
Encoder(Data_Namespace::AbstractBuffer *buffer)
Definition: Encoder.cpp:221
AbstractBuffer * index_buf
ArrayOffsetT last_offset

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_dataSource data for the append
num_elems_to_appendNumber of elements to append
tiSQL Type Info for the column TODO(adb): used?
replicatingPass one value and fill the chunk with it
offsetWrite 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 68 of file ArrayNoneEncoder.h.

References UNREACHABLE.

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

72  {
73  UNREACHABLE(); // should never be called for arrays
74  return nullptr;
75  }
#define UNREACHABLE()
Definition: Logger.h:247

+ 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 77 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(), i, index_buf, is_null(), Data_Namespace::AbstractBuffer::isDirty(), last_offset, MAX_INPUT_BUF_SIZE, Encoder::num_elems_, Data_Namespace::AbstractBuffer::read(), Data_Namespace::AbstractBuffer::reserve(), Data_Namespace::AbstractBuffer::setDirty(), Data_Namespace::AbstractBuffer::size(), and update_elem_stats().

80  {
81  CHECK(index_buf != nullptr); // index_buf must be set before this.
82  size_t index_size = numAppendElems * sizeof(ArrayOffsetT);
83  if (num_elems_ == 0) {
84  index_size += sizeof(ArrayOffsetT); // plus one for the initial offset
85  }
86  index_buf->reserve(index_size);
87 
88  bool first_elem_padded = false;
89  ArrayOffsetT initial_offset = 0;
90  if (num_elems_ == 0) {
91  if ((*srcData)[0].is_null || (*srcData)[0].length <= 1) {
92  // Covers following potentially problematic first arrays:
93  // (1) NULL array, issue - can't encode a NULL with 0 initial offset
94  // otherwise, if first array is not NULL:
95  // (2) length=1 array - could be followed by a {}*/NULL, covers tinyint,bool
96  // (3) empty array - could be followed by {}*/NULL, or {}*|{x}|{}*|NULL, etc.
97  initial_offset = DEFAULT_NULL_PADDING_SIZE;
98  first_elem_padded = true;
99  }
100  index_buf->append((int8_t*)&initial_offset,
101  sizeof(ArrayOffsetT)); // write the initial offset
102  last_offset = initial_offset;
103  } else {
104  // Valid last_offset is never negative
105  // always need to read a valid last offset from buffer/disk
106  // b/c now due to vacuum "last offset" may go backward and if
107  // index chunk was not reloaded last_offset would go way off!
108  index_buf->read((int8_t*)&last_offset,
109  sizeof(ArrayOffsetT),
110  index_buf->size() - sizeof(ArrayOffsetT),
112  CHECK(last_offset != -1);
113  // If the loaded offset is negative it means the last value was a NULL array,
114  // convert to a valid last offset
115  if (last_offset < 0) {
117  }
118  }
119  // Need to start data from 8 byte offset if first array encoded is a NULL array
120  size_t data_size = (first_elem_padded) ? DEFAULT_NULL_PADDING_SIZE : 0;
121  for (size_t n = start_idx; n < start_idx + numAppendElems; n++) {
122  // NULL arrays don't take any space so don't add to the data size
123  if ((*srcData)[replicating ? 0 : n].is_null) {
124  continue;
125  }
126  data_size += (*srcData)[replicating ? 0 : n].length;
127  }
128  buffer_->reserve(data_size);
129 
130  size_t inbuf_size =
131  std::min(std::max(index_size, data_size), (size_t)MAX_INPUT_BUF_SIZE);
132  auto gc_inbuf = std::make_unique<int8_t[]>(inbuf_size);
133  auto inbuf = gc_inbuf.get();
134  for (size_t num_appended = 0; num_appended < numAppendElems;) {
135  ArrayOffsetT* p = (ArrayOffsetT*)inbuf;
136  size_t i;
137  for (i = 0; num_appended < numAppendElems && i < inbuf_size / sizeof(ArrayOffsetT);
138  i++, num_appended++) {
139  p[i] =
140  last_offset + (*srcData)[replicating ? 0 : num_appended + start_idx].length;
141  last_offset = p[i];
142  if ((*srcData)[replicating ? 0 : num_appended + start_idx].is_null) {
143  // Record array NULLness in the index buffer
144  p[i] = -p[i];
145  }
146  }
147  index_buf->append(inbuf, i * sizeof(ArrayOffsetT));
148  }
149 
150  // Pad buffer_ with 8 bytes if first encoded array is a NULL array
151  if (first_elem_padded) {
152  auto padding_size = DEFAULT_NULL_PADDING_SIZE;
153  buffer_->append(inbuf, padding_size);
154  }
155  for (size_t num_appended = 0; num_appended < numAppendElems;) {
156  size_t size = 0;
157  for (int i = start_idx + num_appended;
158  num_appended < numAppendElems && size < inbuf_size;
159  i++, num_appended++) {
160  if ((*srcData)[replicating ? 0 : i].is_null) {
161  continue; // NULL arrays don't take up any space in the data buffer
162  }
163  size_t len = (*srcData)[replicating ? 0 : i].length;
164  if (len > inbuf_size) {
165  // for large strings, append on its own
166  if (size > 0) {
167  buffer_->append(inbuf, size);
168  }
169  size = 0;
170  buffer_->append((*srcData)[replicating ? 0 : i].pointer, len);
171  num_appended++;
172  break;
173  } else if (size + len > inbuf_size) {
174  break;
175  }
176  char* dest = (char*)inbuf + size;
177  if (len > 0) {
178  std::memcpy((void*)dest, (void*)(*srcData)[replicating ? 0 : i].pointer, len);
179  size += len;
180  }
181  }
182  if (size > 0) {
183  buffer_->append(inbuf, size);
184  }
185  }
186  // make sure buffer_ is flushed even if no new data is appended to it
187  // (e.g. empty strings) because the metadata needs to be flushed.
188  if (!buffer_->isDirty()) {
189  buffer_->setDirty();
190  }
191 
192  // keep Chunk statistics with array elements
193  for (size_t n = start_idx; n < start_idx + numAppendElems; n++) {
194  update_elem_stats((*srcData)[replicating ? 0 : n]);
195  }
196  num_elems_ += numAppendElems;
197  auto chunk_metadata = std::make_shared<ChunkMetadata>();
198  getMetadata(chunk_metadata);
199  return chunk_metadata;
200  }
void update_elem_stats(const ArrayDatum &array)
size_t num_elems_
Definition: Encoder.h:237
#define MAX_INPUT_BUF_SIZE
Definition: Encoder.h:36
virtual void read(int8_t *const dst, const size_t num_bytes, const size_t offset=0, const MemoryLevel dst_buffer_type=CPU_LEVEL, const int dst_device_id=-1)=0
CONSTEXPR DEVICE bool is_null(const T &value)
Data_Namespace::AbstractBuffer * buffer_
Definition: Encoder.h:239
void getMetadata(const std::shared_ptr< ChunkMetadata > &chunkMetadata) override
AbstractBuffer * index_buf
static constexpr size_t DEFAULT_NULL_PADDING_SIZE
int32_t ArrayOffsetT
Definition: sqltypes.h:938
virtual void append(int8_t *src, const size_t num_bytes, const MemoryLevel src_buffer_type=CPU_LEVEL, const int device_id=-1)=0
ArrayOffsetT last_offset
#define CHECK(condition)
Definition: Logger.h:203
virtual void reserve(size_t num_bytes)=0

+ Here is the call graph for this function:

void ArrayNoneEncoder::copyMetadata ( const Encoder copyFromEncoder)
inlineoverridevirtual

Implements Encoder.

Definition at line 256 of file ArrayNoneEncoder.h.

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

256  {
257  num_elems_ = copyFromEncoder->getNumElems();
258  auto array_encoder = dynamic_cast<const ArrayNoneEncoder*>(copyFromEncoder);
259  elem_min = array_encoder->elem_min;
260  elem_max = array_encoder->elem_max;
261  has_nulls = array_encoder->has_nulls;
262  initialized = array_encoder->initialized;
263  }
size_t num_elems_
Definition: Encoder.h:237
size_t getNumElems() const
Definition: Encoder.h:233

+ Here is the call graph for this function:

AbstractBuffer* ArrayNoneEncoder::getIndexBuf ( ) const
inline

Definition at line 265 of file ArrayNoneEncoder.h.

References index_buf.

265 { return index_buf; }
AbstractBuffer * index_buf
void ArrayNoneEncoder::getMetadata ( const std::shared_ptr< ChunkMetadata > &  chunkMetadata)
inlineoverridevirtual

Reimplemented from Encoder.

Definition at line 202 of file ArrayNoneEncoder.h.

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

Referenced by appendData().

202  {
203  Encoder::getMetadata(chunkMetadata); // call on parent class
204  chunkMetadata->fillChunkStats(elem_min, elem_max, has_nulls);
205  }
virtual void getMetadata(const std::shared_ptr< ChunkMetadata > &chunkMetadata)
Definition: Encoder.cpp:227

+ 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 208 of file ArrayNoneEncoder.h.

References elem_max, elem_min, and has_nulls.

208  {
209  auto chunk_metadata = std::make_shared<ChunkMetadata>(
210  ti, 0, 0, ChunkStats{elem_min, elem_max, has_nulls});
211  return chunk_metadata;
212  }
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.

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

54  {
55  size_t dataSize = 0;
56 
57  size_t n = start_idx;
58  for (; n < start_idx + numAppendElems; n++) {
59  size_t len = (*srcData)[replicating ? 0 : n].length;
60  if (dataSize + len > byteLimit) {
61  break;
62  }
63  dataSize += len;
64  }
65  return n - start_idx;
66  }

+ Here is the caller graph for this function:

void ArrayNoneEncoder::readMetadata ( FILE *  f)
inlineoverridevirtual

Implements Encoder.

Definition at line 247 of file ArrayNoneEncoder.h.

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

247  {
248  // assumes pointer is already in right place
249  fread((int8_t*)&num_elems_, sizeof(size_t), 1, f);
250  fread((int8_t*)&elem_min, sizeof(Datum), 1, f);
251  fread((int8_t*)&elem_max, sizeof(Datum), 1, f);
252  fread((int8_t*)&has_nulls, sizeof(bool), 1, f);
253  fread((int8_t*)&initialized, sizeof(bool), 1, f);
254  }
size_t num_elems_
Definition: Encoder.h:237
char * f
void ArrayNoneEncoder::reduceStats ( const Encoder )
inlineoverridevirtual

Implements Encoder.

Definition at line 236 of file ArrayNoneEncoder.h.

References CHECK.

236 { CHECK(false); }
#define CHECK(condition)
Definition: Logger.h:203
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 267 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, ChunkStats::max, and ChunkStats::min.

267  {
268  auto elem_type = buffer_->getSqlType().get_elem_type();
269  if (DatumEqual(elem_min, stats.min, elem_type) &&
270  DatumEqual(elem_max, stats.max, elem_type) && has_nulls == stats.has_nulls) {
271  return false;
272  }
273  elem_min = stats.min;
274  elem_max = stats.max;
275  has_nulls = stats.has_nulls;
276  return true;
277  }
Data_Namespace::AbstractBuffer * buffer_
Definition: Encoder.h:239
bool DatumEqual(const Datum a, const Datum b, const SQLTypeInfo &ti)
Definition: Datum.cpp:306
SQLTypeInfo getSqlType() const
SQLTypeInfo get_elem_type() const
Definition: sqltypes.h:713

+ 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 279 of file ArrayNoneEncoder.h.

References has_nulls, and initialized.

279  {
280  has_nulls = false;
281  initialized = false;
282  }
void ArrayNoneEncoder::setIndexBuffer ( AbstractBuffer buf)
inline

Definition at line 288 of file ArrayNoneEncoder.h.

References EncoderMutex_, and index_buf.

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

288  {
289  std::unique_lock<std::mutex> lock(EncoderMutex_);
290  index_buf = buf;
291  }
std::mutex EncoderMutex_
AbstractBuffer * index_buf

+ Here is the caller graph for this function:

void ArrayNoneEncoder::update_elem_stats ( const ArrayDatum array)
inlineprivate

Definition at line 300 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, i, 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().

300  {
301  if (array.is_null) {
302  has_nulls = true;
303  }
304  switch (buffer_->getSqlType().get_subtype()) {
305  case kBOOLEAN: {
306  if (!initialized) {
307  elem_min.boolval = true;
308  elem_max.boolval = false;
309  }
310  if (array.is_null || array.length == 0) {
311  break;
312  }
313  const bool* bool_array = (bool*)array.pointer;
314  for (size_t i = 0; i < array.length / sizeof(bool); i++) {
315  if ((int8_t)bool_array[i] == NULL_BOOLEAN) {
316  has_nulls = true;
317  } else if (initialized) {
318  elem_min.boolval = std::min(elem_min.boolval, bool_array[i]);
319  elem_max.boolval = std::max(elem_max.boolval, bool_array[i]);
320  } else {
321  elem_min.boolval = bool_array[i];
322  elem_max.boolval = bool_array[i];
323  initialized = true;
324  }
325  }
326  break;
327  }
328  case kINT: {
329  if (!initialized) {
330  elem_min.intval = 1;
331  elem_max.intval = 0;
332  }
333  if (array.is_null || array.length == 0) {
334  break;
335  }
336  const int32_t* int_array = (int32_t*)array.pointer;
337  for (size_t i = 0; i < array.length / sizeof(int32_t); i++) {
338  if (int_array[i] == NULL_INT) {
339  has_nulls = true;
340  } else if (initialized) {
341  elem_min.intval = std::min(elem_min.intval, int_array[i]);
342  elem_max.intval = std::max(elem_max.intval, int_array[i]);
343  } else {
344  elem_min.intval = int_array[i];
345  elem_max.intval = int_array[i];
346  initialized = true;
347  }
348  }
349  break;
350  }
351  case kSMALLINT: {
352  if (!initialized) {
353  elem_min.smallintval = 1;
354  elem_max.smallintval = 0;
355  }
356  if (array.is_null || array.length == 0) {
357  break;
358  }
359  const int16_t* int_array = (int16_t*)array.pointer;
360  for (size_t i = 0; i < array.length / sizeof(int16_t); i++) {
361  if (int_array[i] == NULL_SMALLINT) {
362  has_nulls = true;
363  } else if (initialized) {
364  elem_min.smallintval = std::min(elem_min.smallintval, int_array[i]);
365  elem_max.smallintval = std::max(elem_max.smallintval, int_array[i]);
366  } else {
367  elem_min.smallintval = int_array[i];
368  elem_max.smallintval = int_array[i];
369  initialized = true;
370  }
371  }
372  break;
373  }
374  case kTINYINT: {
375  if (!initialized) {
376  elem_min.tinyintval = 1;
377  elem_max.tinyintval = 0;
378  }
379  if (array.is_null || array.length == 0) {
380  break;
381  }
382  const int8_t* int_array = (int8_t*)array.pointer;
383  for (size_t i = 0; i < array.length / sizeof(int8_t); i++) {
384  if (int_array[i] == NULL_TINYINT) {
385  has_nulls = true;
386  } else if (initialized) {
387  elem_min.tinyintval = std::min(elem_min.tinyintval, int_array[i]);
388  elem_max.tinyintval = std::max(elem_max.tinyintval, int_array[i]);
389  } else {
390  elem_min.tinyintval = int_array[i];
391  elem_max.tinyintval = int_array[i];
392  initialized = true;
393  }
394  }
395  break;
396  }
397  case kBIGINT:
398  case kNUMERIC:
399  case kDECIMAL: {
400  if (!initialized) {
401  elem_min.bigintval = 1;
402  elem_max.bigintval = 0;
403  }
404  if (array.is_null || array.length == 0) {
405  break;
406  }
407  const int64_t* int_array = (int64_t*)array.pointer;
408  for (size_t i = 0; i < array.length / sizeof(int64_t); i++) {
409  if (int_array[i] == NULL_BIGINT) {
410  has_nulls = true;
411  } else if (initialized) {
412  elem_min.bigintval = std::min(elem_min.bigintval, int_array[i]);
413  elem_max.bigintval = std::max(elem_max.bigintval, int_array[i]);
414  } else {
415  elem_min.bigintval = int_array[i];
416  elem_max.bigintval = int_array[i];
417  initialized = true;
418  }
419  }
420  break;
421  }
422  case kFLOAT: {
423  if (!initialized) {
424  elem_min.floatval = 1.0;
425  elem_max.floatval = 0.0;
426  }
427  if (array.is_null || array.length == 0) {
428  break;
429  }
430  const float* flt_array = (float*)array.pointer;
431  for (size_t i = 0; i < array.length / sizeof(float); i++) {
432  if (flt_array[i] == NULL_FLOAT) {
433  has_nulls = true;
434  } else if (initialized) {
435  elem_min.floatval = std::min(elem_min.floatval, flt_array[i]);
436  elem_max.floatval = std::max(elem_max.floatval, flt_array[i]);
437  } else {
438  elem_min.floatval = flt_array[i];
439  elem_max.floatval = flt_array[i];
440  initialized = true;
441  }
442  }
443  break;
444  }
445  case kDOUBLE: {
446  if (!initialized) {
447  elem_min.doubleval = 1.0;
448  elem_max.doubleval = 0.0;
449  }
450  if (array.is_null || array.length == 0) {
451  break;
452  }
453  const double* dbl_array = (double*)array.pointer;
454  for (size_t i = 0; i < array.length / sizeof(double); i++) {
455  if (dbl_array[i] == NULL_DOUBLE) {
456  has_nulls = true;
457  } else if (initialized) {
458  elem_min.doubleval = std::min(elem_min.doubleval, dbl_array[i]);
459  elem_max.doubleval = std::max(elem_max.doubleval, dbl_array[i]);
460  } else {
461  elem_min.doubleval = dbl_array[i];
462  elem_max.doubleval = dbl_array[i];
463  initialized = true;
464  }
465  }
466  break;
467  }
468  case kTIME:
469  case kTIMESTAMP:
470  case kDATE: {
471  if (!initialized) {
472  elem_min.bigintval = 1;
473  elem_max.bigintval = 0;
474  }
475  if (array.is_null || array.length == 0) {
476  break;
477  }
478  const auto tm_array = reinterpret_cast<int64_t*>(array.pointer);
479  for (size_t i = 0; i < array.length / sizeof(int64_t); i++) {
480  if (tm_array[i] == NULL_BIGINT) {
481  has_nulls = true;
482  } else if (initialized) {
483  elem_min.bigintval = std::min(elem_min.bigintval, tm_array[i]);
484  elem_max.bigintval = std::max(elem_max.bigintval, tm_array[i]);
485  } else {
486  elem_min.bigintval = tm_array[i];
487  elem_max.bigintval = tm_array[i];
488  initialized = true;
489  }
490  }
491  break;
492  }
493  case kCHAR:
494  case kVARCHAR:
495  case kTEXT: {
497  if (!initialized) {
498  elem_min.intval = 1;
499  elem_max.intval = 0;
500  }
501  if (array.is_null || array.length == 0) {
502  break;
503  }
504  const int32_t* int_array = (int32_t*)array.pointer;
505  for (size_t i = 0; i < array.length / sizeof(int32_t); i++) {
506  if (int_array[i] == NULL_INT) {
507  has_nulls = true;
508  } else if (initialized) {
509  elem_min.intval = std::min(elem_min.intval, int_array[i]);
510  elem_max.intval = std::max(elem_max.intval, int_array[i]);
511  } else {
512  elem_min.intval = int_array[i];
513  elem_max.intval = int_array[i];
514  initialized = true;
515  }
516  }
517  break;
518  }
519  default:
520  UNREACHABLE();
521  }
522  };
int8_t tinyintval
Definition: sqltypes.h:206
HOST DEVICE SQLTypes get_subtype() const
Definition: sqltypes.h:315
#define CHECK_EQ(x, y)
Definition: Logger.h:211
#define NULL_DOUBLE
Definition: sqltypes.h:48
#define NULL_FLOAT
#define NULL_BIGINT
bool boolval
Definition: sqltypes.h:205
#define UNREACHABLE()
Definition: Logger.h:247
int32_t intval
Definition: sqltypes.h:208
#define NULL_INT
float floatval
Definition: sqltypes.h:210
Data_Namespace::AbstractBuffer * buffer_
Definition: Encoder.h:239
int64_t bigintval
Definition: sqltypes.h:209
int16_t smallintval
Definition: sqltypes.h:207
#define NULL_BOOLEAN
Definition: sqltypes.h:51
Definition: sqltypes.h:52
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:322
Definition: sqltypes.h:40
SQLTypeInfo getSqlType() const
#define NULL_TINYINT
#define NULL_SMALLINT
Definition: sqltypes.h:44
double doubleval
Definition: sqltypes.h:211

+ 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 214 of file ArrayNoneEncoder.h.

References CHECK.

214 { CHECK(false); }
#define CHECK(condition)
Definition: Logger.h:203
void ArrayNoneEncoder::updateStats ( const double  ,
const bool   
)
inlineoverridevirtual

Implements Encoder.

Definition at line 216 of file ArrayNoneEncoder.h.

References CHECK.

216 { CHECK(false); }
#define CHECK(condition)
Definition: Logger.h:203
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 218 of file ArrayNoneEncoder.h.

References CHECK.

218  {
219  CHECK(false);
220  }
#define CHECK(condition)
Definition: Logger.h:203
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 222 of file ArrayNoneEncoder.h.

References UNREACHABLE.

224  {
225  UNREACHABLE();
226  }
#define UNREACHABLE()
Definition: Logger.h:247
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 228 of file ArrayNoneEncoder.h.

References update_elem_stats().

230  {
231  for (size_t n = start_idx; n < start_idx + num_elements; n++) {
232  update_elem_stats((*src_data)[n]);
233  }
234  }
void update_elem_stats(const ArrayDatum &array)

+ Here is the call graph for this function:

void ArrayNoneEncoder::writeMetadata ( FILE *  f)
inlineoverridevirtual

Implements Encoder.

Definition at line 238 of file ArrayNoneEncoder.h.

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

238  {
239  // assumes pointer is already in right place
240  fwrite((int8_t*)&num_elems_, sizeof(size_t), 1, f);
241  fwrite((int8_t*)&elem_min, sizeof(Datum), 1, f);
242  fwrite((int8_t*)&elem_max, sizeof(Datum), 1, f);
243  fwrite((int8_t*)&has_nulls, sizeof(bool), 1, f);
244  fwrite((int8_t*)&initialized, sizeof(bool), 1, f);
245  }
size_t num_elems_
Definition: Encoder.h:237
char * f

Member Data Documentation

constexpr size_t ArrayNoneEncoder::DEFAULT_NULL_PADDING_SIZE {8}
static
Datum ArrayNoneEncoder::elem_max
Datum ArrayNoneEncoder::elem_min
std::mutex ArrayNoneEncoder::EncoderMutex_
private

Definition at line 296 of file ArrayNoneEncoder.h.

Referenced by setIndexBuffer().

AbstractBuffer* ArrayNoneEncoder::index_buf
private

Definition at line 297 of file ArrayNoneEncoder.h.

Referenced by appendData(), getIndexBuf(), and setIndexBuffer().

bool ArrayNoneEncoder::initialized
ArrayOffsetT ArrayNoneEncoder::last_offset
private

Definition at line 298 of file ArrayNoneEncoder.h.

Referenced by appendData().


The documentation for this class was generated from the following file: