FixedLengthEncoder< T, V > Class Template Reference

#include <FixedLengthEncoder.h>

Inheritance diagram for FixedLengthEncoder< T, V >:

Collaboration diagram for FixedLengthEncoder< T, V >:

Public Member Functions
	FixedLengthEncoder (Data_Namespace::AbstractBuffer *buffer)
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 >	appendEncodedDataAtIndices (const int8_t *, int8_t *data, const std::vector< size_t > &selected_idx) override
std::shared_ptr< ChunkMetadata >	appendEncodedData (const int8_t *, int8_t *data, const size_t start_idx, const size_t num_elements) 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
void	getMetadata (const std::shared_ptr< ChunkMetadata > &chunkMetadata) override
std::shared_ptr< ChunkMetadata >	getMetadata (const SQLTypeInfo &ti) override
void	updateStats (const int64_t val, const bool is_null) override
void	updateStats (const double val, const bool is_null) override
void	updateStats (const int8_t *const src_data, const size_t num_elements) override
void	updateStatsEncoded (const int8_t *const dst_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 &that) override
void	copyMetadata (const Encoder *copyFromEncoder) override
void	writeMetadata (FILE *f) override
void	readMetadata (FILE *f) override
bool	resetChunkStats (const ChunkStats &stats) override
	: Reset chunk level stats (min, max, nulls) using new values from the argument. More...
void	resetChunkStats () override
Public Member Functions inherited from Encoder
	Encoder (Data_Namespace::AbstractBuffer *buffer)
virtual	~Encoder ()
size_t	getNumElems () const
void	setNumElems (const size_t num_elems)

Public Attributes
T	dataMin
T	dataMax
bool	has_nulls

Private Member Functions
std::shared_ptr< ChunkMetadata >	appendEncodedOrUnencodedData (int8_t *&src_data, const size_t num_elems_to_append, const SQLTypeInfo &ti, const bool replicating, const int64_t offset, const bool is_encoded)
void	updateStatsWithAlreadyEncoded (const V &encoded_data)
V	encodeDataAndUpdateStats (const T &unencoded_data)

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

template<typename T, typename V>
class FixedLengthEncoder< T, V >

Definition at line 34 of file FixedLengthEncoder.h.

Constructor & Destructor Documentation

template<typename T, typename V>

FixedLengthEncoder< T, V >::FixedLengthEncoder ( Data_Namespace::AbstractBuffer *  buffer )

inline

Definition at line 36 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::resetChunkStats().

                                                           : Encoder(buffer) {
    resetChunkStats();
  }

Here is the call graph for this function:

Member Function Documentation

template<typename T, typename V>

std::shared_ptr<ChunkMetadata> FixedLengthEncoder< T, V >::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 75 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData().

                                                                                {
    return appendEncodedOrUnencodedData(
        src_data, num_elems_to_append, ti, replicating, offset, false);
  }

Here is the call graph for this function:

template<typename T, typename V>

std::shared_ptr<ChunkMetadata> FixedLengthEncoder< T, V >::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 66 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData().

Referenced by FixedLengthEncoder< T, V >::appendEncodedDataAtIndices().

                                                                                       {
    auto current_data = data + start_idx * sizeof(V);
    return appendEncodedOrUnencodedData(
        current_data, num_elements, SQLTypeInfo{}, false, -1, true);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T, typename V>

std::shared_ptr<ChunkMetadata> FixedLengthEncoder< T, V >::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 49 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::appendEncodedData(), and shared::execute_over_contiguous_indices().

                                                      {
    std::shared_ptr<ChunkMetadata> chunk_metadata;
    // NOTE: the use of `execute_over_contiguous_indices` is an optimization;
    // it prevents having to copy or move the indexed data and instead performs
    // an append over contiguous sections of indices.
    shared::execute_over_contiguous_indices(
        selected_idx, [&](const size_t start_pos, const size_t end_pos) {
          size_t elem_count = end_pos - start_pos;
          chunk_metadata =
              appendEncodedData(nullptr, data, selected_idx[start_pos], elem_count);
        });
    return chunk_metadata;
  }

Here is the call graph for this function:

template<typename T, typename V>

std::shared_ptr<ChunkMetadata> FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData ( int8_t *&  src_data, const size_t  num_elems_to_append, const SQLTypeInfo &  ti, const bool  replicating, const int64_t  offset, const bool  is_encoded  )

inlineprivate

Definition at line 226 of file FixedLengthEncoder.h.

References Data_Namespace::AbstractBuffer::append(), Encoder::buffer_, CHECK, CHECK_GE, FixedLengthEncoder< T, V >::encodeDataAndUpdateStats(), FixedLengthEncoder< T, V >::getMetadata(), Encoder::num_elems_, Data_Namespace::AbstractBuffer::reserve(), FixedLengthEncoder< T, V >::resetChunkStats(), Data_Namespace::AbstractBuffer::size(), heavydb.dtypes::T, FixedLengthEncoder< T, V >::updateStatsWithAlreadyEncoded(), and Data_Namespace::AbstractBuffer::write().

Referenced by FixedLengthEncoder< T, V >::appendData(), and FixedLengthEncoder< T, V >::appendEncodedData().

                             {
    if (offset == 0 &&
        num_elems_to_append >=
            num_elems_) {  // we're rewriting entire buffer so fully recompute metadata
      resetChunkStats();
    }

    CHECK(!is_encoded || !replicating);  // do not support replicating of encoded data

    T* unencoded_data = reinterpret_cast<T*>(src_data);
    std::vector<V> encoded_data;
    V* data_to_write = nullptr;
    if (!is_encoded) {
      encoded_data.resize(num_elems_to_append);
      data_to_write = encoded_data.data();
      for (size_t i = 0; i < num_elems_to_append; ++i) {
        size_t ri = replicating ? 0 : i;
        encoded_data[i] = encodeDataAndUpdateStats(unencoded_data[ri]);
      }
    } else {
      data_to_write = reinterpret_cast<V*>(src_data);
      for (size_t i = 0; i < num_elems_to_append; ++i) {
        updateStatsWithAlreadyEncoded(data_to_write[i]);
      }
    }

    // assume always CPU_BUFFER?
    if (offset == -1) {
      auto append_data_size = num_elems_to_append * sizeof(V);
      buffer_->reserve(buffer_->size() + append_data_size);
      num_elems_ += num_elems_to_append;
      buffer_->append(reinterpret_cast<int8_t*>(data_to_write), append_data_size);
      if (!replicating) {
        src_data += num_elems_to_append * sizeof(T);
      }
    } else {
      num_elems_ = offset + num_elems_to_append;
      CHECK(!replicating);
      CHECK_GE(offset, 0);
      buffer_->write(reinterpret_cast<int8_t*>(data_to_write),
                     num_elems_to_append * sizeof(V),
                     static_cast<size_t>(offset));
    }
    auto chunk_metadata = std::make_shared<ChunkMetadata>();
    getMetadata(chunk_metadata);
    return chunk_metadata;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::copyMetadata ( const Encoder *  copyFromEncoder )

inlineoverridevirtual

Implements Encoder.

Definition at line 176 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, Encoder::getNumElems(), FixedLengthEncoder< T, V >::has_nulls, and Encoder::num_elems_.

                                                             {
    num_elems_ = copyFromEncoder->getNumElems();
    auto castedEncoder =
        reinterpret_cast<const FixedLengthEncoder<T, V>*>(copyFromEncoder);
    dataMin = castedEncoder->dataMin;
    dataMax = castedEncoder->dataMax;
    has_nulls = castedEncoder->has_nulls;
  }

Here is the call graph for this function:

template<typename T, typename V>

V FixedLengthEncoder< T, V >::encodeDataAndUpdateStats ( const T &  unencoded_data )

inlineprivate

Definition at line 289 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, Encoder::decimal_overflow_validator_, logger::ERROR, FixedLengthEncoder< T, V >::has_nulls, LOG, heavydb.dtypes::T, to_string(), and DecimalOverflowValidator::validate().

Referenced by FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData(), and FixedLengthEncoder< T, V >::updateStats().

                                                      {
    V encoded_data = static_cast<V>(unencoded_data);
    if (unencoded_data != encoded_data) {
      decimal_overflow_validator_.validate(unencoded_data);
      LOG(ERROR) << "Fixed encoding failed, Unencoded: " +
                        std::to_string(unencoded_data) +
                        " encoded: " + std::to_string(encoded_data);
    } else {
      T data = unencoded_data;
      if (data == std::numeric_limits<V>::min()) {
        has_nulls = true;
      } else {
        decimal_overflow_validator_.validate(data);
        dataMin = std::min(dataMin, data);
        dataMax = std::max(dataMax, data);
      }
    }
    return encoded_data;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::getMetadata ( const std::shared_ptr< ChunkMetadata > &  chunkMetadata )

inlineoverridevirtual

Reimplemented from Encoder.

Definition at line 84 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, Encoder::getMetadata(), and FixedLengthEncoder< T, V >::has_nulls.

Referenced by FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData().

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

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T, typename V>

std::shared_ptr<ChunkMetadata> FixedLengthEncoder< T, V >::getMetadata ( const SQLTypeInfo &  ti )

inlineoverridevirtual

Implements Encoder.

Definition at line 90 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, and FixedLengthEncoder< T, V >::has_nulls.

                                                                           {
    auto chunk_metadata = std::make_shared<ChunkMetadata>(ti, 0, 0, ChunkStats{});
    chunk_metadata->fillChunkStats(dataMin, dataMax, has_nulls);
    return chunk_metadata;
  }

template<typename T, typename V>

size_t FixedLengthEncoder< T, V >::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 40 of file FixedLengthEncoder.h.

References UNREACHABLE.

                                                                                   {
    UNREACHABLE()
        << "getNumElemsForBytesEncodedDataAtIndices unexpectedly called for non varlen"
           " encoder";
    return {};
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::readMetadata ( FILE *  f )

inlineoverridevirtual

Implements Encoder.

Definition at line 193 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, FixedLengthEncoder< T, V >::has_nulls, Encoder::num_elems_, and heavydb.dtypes::T.

                                      {
    // assumes pointer is already in right place
    fread((int8_t*)&num_elems_, sizeof(size_t), 1, f);
    fread((int8_t*)&dataMin, 1, sizeof(T), f);
    fread((int8_t*)&dataMax, 1, sizeof(T), f);
    fread((int8_t*)&has_nulls, 1, sizeof(bool), f);
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::reduceStats ( const Encoder &  that )

inlineoverridevirtual

Implements Encoder.

Definition at line 167 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, and FixedLengthEncoder< T, V >::has_nulls.

                                                 {
    const auto that_typed = static_cast<const FixedLengthEncoder<T, V>&>(that);
    if (that_typed.has_nulls) {
      has_nulls = true;
    }
    dataMin = std::min(dataMin, that_typed.dataMin);
    dataMax = std::max(dataMax, that_typed.dataMax);
  }

template<typename T, typename V>

bool FixedLengthEncoder< T, V >::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 201 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, ChunkStats::has_nulls, FixedLengthEncoder< T, V >::has_nulls, ChunkStats::max, and ChunkStats::min.

                                                         {
    const auto new_min = DatumFetcher::getDatumVal<T>(stats.min);
    const auto new_max = DatumFetcher::getDatumVal<T>(stats.max);

    if (dataMin == new_min && dataMax == new_max && has_nulls == stats.has_nulls) {
      return false;
    }

    dataMin = new_min;
    dataMax = new_max;
    has_nulls = stats.has_nulls;
    return true;
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::resetChunkStats ( )

inlineoverridevirtual

Resets chunk metadata stats to their default values.

Implements Encoder.

Definition at line 215 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, and FixedLengthEncoder< T, V >::has_nulls.

Referenced by FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData(), and FixedLengthEncoder< T, V >::FixedLengthEncoder().

                                  {
    dataMin = std::numeric_limits<T>::max();
    dataMax = std::numeric_limits<T>::lowest();
    has_nulls = false;
  }

Here is the caller graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::updateStats ( const int64_t  val, const bool  is_null  )

inlineoverridevirtual

Implements Encoder.

Definition at line 97 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, FixedLengthEncoder< T, V >::has_nulls, and heavydb.dtypes::T.

                                                                   {
    if (is_null) {
      has_nulls = true;
    } else {
      const auto data = static_cast<T>(val);
      dataMin = std::min(dataMin, data);
      dataMax = std::max(dataMax, data);
    }
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::updateStats ( const double  val, const bool  is_null  )

inlineoverridevirtual

Implements Encoder.

Definition at line 108 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, FixedLengthEncoder< T, V >::has_nulls, and heavydb.dtypes::T.

                                                                  {
    if (is_null) {
      has_nulls = true;
    } else {
      const auto data = static_cast<T>(val);
      dataMin = std::min(dataMin, data);
      dataMax = std::max(dataMax, data);
    }
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::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 118 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::encodeDataAndUpdateStats(), and heavydb.dtypes::T.

                                                                                     {
    const T* unencoded_data = reinterpret_cast<const T*>(src_data);
    for (size_t i = 0; i < num_elements; ++i) {
      encodeDataAndUpdateStats(unencoded_data[i]);
    }
  }

Here is the call graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::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 154 of file FixedLengthEncoder.h.

References UNREACHABLE.

                                                       {
    UNREACHABLE();
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::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 160 of file FixedLengthEncoder.h.

References UNREACHABLE.

                                                       {
    UNREACHABLE();
  }

template<typename T, typename V>

void FixedLengthEncoder< T, V >::updateStatsEncoded ( const int8_t *const  dst_data, const size_t  num_elements  )

inlineoverridevirtual

Update statistics for encoded data without appending.

Parameters

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

Reimplemented from Encoder.

Definition at line 125 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, Encoder::decimal_overflow_validator_, FixedLengthEncoder< T, V >::has_nulls, logger::init(), threading_serial::parallel_reduce(), and DecimalOverflowValidator::validate().

                                                              {
    const V* data = reinterpret_cast<const V*>(dst_data);

    std::tie(dataMin, dataMax, has_nulls) = tbb::parallel_reduce(
        tbb::blocked_range(size_t(0), num_elements),
        std::tuple(static_cast<V>(dataMin), static_cast<V>(dataMax), has_nulls),
        [&](const auto& range, auto init) {
          auto [min, max, nulls] = init;
          for (size_t i = range.begin(); i < range.end(); i++) {
            if (data[i] != std::numeric_limits<V>::min()) {
              decimal_overflow_validator_.validate(data[i]);
              min = std::min(min, data[i]);
              max = std::max(max, data[i]);
            } else {
              nulls = true;
            }
          }
          return std::tuple(min, max, nulls);
        },
        [&](auto lhs, auto rhs) {
          const auto [lhs_min, lhs_max, lhs_nulls] = lhs;
          const auto [rhs_min, rhs_max, rhs_nulls] = rhs;
          return std::tuple(std::min(lhs_min, rhs_min),
                            std::max(lhs_max, rhs_max),
                            lhs_nulls || rhs_nulls);
        });
  }

Here is the call graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::updateStatsWithAlreadyEncoded ( const V &  encoded_data )

inlineprivate

Definition at line 280 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, and FixedLengthEncoder< T, V >::has_nulls.

Referenced by FixedLengthEncoder< T, V >::appendEncodedOrUnencodedData().

                                                            {
    if (encoded_data == std::numeric_limits<V>::min()) {
      has_nulls = true;
    } else {
      dataMin = std::min<T>(dataMin, encoded_data);
      dataMax = std::max<T>(dataMax, encoded_data);
    }
  }

Here is the caller graph for this function:

template<typename T, typename V>

void FixedLengthEncoder< T, V >::writeMetadata ( FILE *  f )

inlineoverridevirtual

Implements Encoder.

Definition at line 185 of file FixedLengthEncoder.h.

References FixedLengthEncoder< T, V >::dataMax, FixedLengthEncoder< T, V >::dataMin, FixedLengthEncoder< T, V >::has_nulls, Encoder::num_elems_, and heavydb.dtypes::T.

                                       {
    // assumes pointer is already in right place
    fwrite((int8_t*)&num_elems_, sizeof(size_t), 1, f);
    fwrite((int8_t*)&dataMin, sizeof(T), 1, f);
    fwrite((int8_t*)&dataMax, sizeof(T), 1, f);
    fwrite((int8_t*)&has_nulls, sizeof(bool), 1, f);
  }

Member Data Documentation

template<typename T, typename V>

T FixedLengthEncoder< T, V >::dataMax

Definition at line 222 of file FixedLengthEncoder.h.

Referenced by FixedLengthEncoder< T, V >::copyMetadata(), FixedLengthEncoder< T, V >::encodeDataAndUpdateStats(), FixedLengthEncoder< T, V >::getMetadata(), FixedLengthEncoder< T, V >::readMetadata(), FixedLengthEncoder< T, V >::reduceStats(), FixedLengthEncoder< T, V >::resetChunkStats(), FixedLengthEncoder< T, V >::updateStats(), FixedLengthEncoder< T, V >::updateStatsEncoded(), FixedLengthEncoder< T, V >::updateStatsWithAlreadyEncoded(), and FixedLengthEncoder< T, V >::writeMetadata().

template<typename T, typename V>

T FixedLengthEncoder< T, V >::dataMin

Definition at line 221 of file FixedLengthEncoder.h.

Referenced by FixedLengthEncoder< T, V >::copyMetadata(), FixedLengthEncoder< T, V >::encodeDataAndUpdateStats(), FixedLengthEncoder< T, V >::getMetadata(), FixedLengthEncoder< T, V >::readMetadata(), FixedLengthEncoder< T, V >::reduceStats(), FixedLengthEncoder< T, V >::resetChunkStats(), FixedLengthEncoder< T, V >::updateStats(), FixedLengthEncoder< T, V >::updateStatsEncoded(), FixedLengthEncoder< T, V >::updateStatsWithAlreadyEncoded(), and FixedLengthEncoder< T, V >::writeMetadata().

template<typename T, typename V>

bool FixedLengthEncoder< T, V >::has_nulls

Definition at line 223 of file FixedLengthEncoder.h.

Referenced by FixedLengthEncoder< T, V >::copyMetadata(), FixedLengthEncoder< T, V >::encodeDataAndUpdateStats(), FixedLengthEncoder< T, V >::getMetadata(), heavydb.thrift.ttypes.TColumnRange::read(), FixedLengthEncoder< T, V >::readMetadata(), FixedLengthEncoder< T, V >::reduceStats(), FixedLengthEncoder< T, V >::resetChunkStats(), FixedLengthEncoder< T, V >::updateStats(), FixedLengthEncoder< T, V >::updateStatsEncoded(), FixedLengthEncoder< T, V >::updateStatsWithAlreadyEncoded(), heavydb.thrift.ttypes.TColumnRange::write(), and FixedLengthEncoder< T, V >::writeMetadata().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/DataMgr/FixedLengthEncoder.h