#include "ChunkIter.h"
#include <cstdlib>

Include dependency graph for ChunkIter.cpp:

This graph shows which files directly or indirectly include this file:

Functions
static DEVICE void	decompress (const SQLTypeInfo &ti, int8_t compressed, VarlenDatum result, Datum *datum)

void	ChunkIter_reset (ChunkIter *it)

DEVICE void	ChunkIter_get_next (ChunkIter it, bool uncompress, VarlenDatum result, bool *is_end)

DEVICE void	ChunkIter_get_nth (ChunkIter it, int n, bool uncompress, VarlenDatum result, bool *is_end)

DEVICE void	ChunkIter_get_nth (ChunkIter it, int n, ArrayDatum result, bool *is_end)

DEVICE void	ChunkIter_get_nth_varlen (ChunkIter it, int n, ArrayDatum result, bool *is_end)

DEVICE void	ChunkIter_get_nth_varlen_notnull (ChunkIter it, int n, ArrayDatum result, bool *is_end)

DEVICE void	ChunkIter_get_nth_point_coords (ChunkIter it, int n, ArrayDatum result, bool *is_end)

Function Documentation

DEVICE void ChunkIter_get_next	(	ChunkIter *	it,
		bool	uncompress,
		VarlenDatum *	result,
		bool *	is_end
	)

Definition at line 148 of file ChunkIter.cpp.

References ChunkIter::current_pos, ChunkIter::datum, decompress(), ChunkIter::end_pos, SQLTypeInfo::get_compression(), VarlenDatum::is_null, SQLTypeInfo::is_null(), kENCODING_NONE, VarlenDatum::length, VarlenDatum::pointer, ChunkIter::second_buf, ChunkIter::skip, ChunkIter::skip_size, and ChunkIter::type_info.

                                              {
   if (!it || it->current_pos >= it->end_pos) {
     *is_end = true;
     result->length = 0;
     result->pointer = NULL;
     result->is_null = true;
     return;
   }
   *is_end = false;
 
   if (it->skip_size > 0) {
     // for fixed-size
     if (uncompress && (it->type_info.get_compression() != kENCODING_NONE)) {
       decompress(it->type_info, it->current_pos, result, &it->datum);
     } else {
       result->length = static_cast<size_t>(it->skip_size);
       result->pointer = it->current_pos;
       result->is_null = it->type_info.is_null(result->pointer);
     }
     it->current_pos += it->skip * it->skip_size;
   } else {
     StringOffsetT offset = *(StringOffsetT*)it->current_pos;
     result->length = static_cast<size_t>(*((StringOffsetT*)it->current_pos + 1) - offset);
     result->pointer = it->second_buf + offset;
     // @TODO(wei) treat zero length as null for now
     result->is_null = (result->length == 0);
     it->current_pos += it->skip * sizeof(StringOffsetT);
   }
 }

Here is the call graph for this function:

DEVICE void ChunkIter_get_nth	(	ChunkIter *	it,
		int	n,
		bool	uncompress,
		VarlenDatum *	result,
		bool *	is_end
	)

Definition at line 182 of file ChunkIter.cpp.

References ChunkIter::datum, decompress(), SQLTypeInfo::get_compression(), VarlenDatum::is_null, SQLTypeInfo::is_null(), FlatBufferManager::isFlatBuffer(), kENCODING_NONE, VarlenDatum::length, ChunkIter::num_elems, VarlenDatum::pointer, ChunkIter::second_buf, ChunkIter::skip_size, ChunkIter::start_pos, ChunkIter::type_info, and VarlenArray_get_nth().

Referenced by anonymous_namespace{ResultSetIteration.cpp}::lazy_fetch_chunk(), ResultSet::lazyReadInt(), ResultSet::makeVarlenTargetValue(), string_decode(), and anonymous_namespace{ExternalExecutor.cpp}::vt_column().

                                             {
   if (FlatBufferManager::isFlatBuffer(it)) {
     VarlenArray_get_nth(reinterpret_cast<int8_t*>(it), n, uncompress, result, is_end);
     return;
   }
   if (!it || static_cast<size_t>(n) >= it->num_elems || n < 0) {
     *is_end = true;
     result->length = 0;
     result->pointer = NULL;
     result->is_null = true;
     return;
   }
   *is_end = false;
 
   if (it->skip_size > 0) {
     // for fixed-size
     int8_t* current_pos = it->start_pos + n * it->skip_size;
     if (uncompress && (it->type_info.get_compression() != kENCODING_NONE)) {
       decompress(it->type_info, current_pos, result, &it->datum);
     } else {
       result->length = static_cast<size_t>(it->skip_size);
       result->pointer = current_pos;
       result->is_null = it->type_info.is_null(result->pointer);
     }
   } else {
     int8_t* current_pos = it->start_pos + n * sizeof(StringOffsetT);
     StringOffsetT offset = *(StringOffsetT*)current_pos;
     result->length = static_cast<size_t>(*((StringOffsetT*)current_pos + 1) - offset);
     result->pointer = it->second_buf + offset;
     // @TODO(wei) treat zero length as null for now
     result->is_null = (result->length == 0);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE void ChunkIter_get_nth	(	ChunkIter *	it,
		int	n,
		ArrayDatum *	result,
		bool *	is_end
	)

Definition at line 221 of file ChunkIter.cpp.

References SQLTypeInfo::get_notnull(), is_null(), SQLTypeInfo::is_null_fixlen_array(), FlatBufferManager::isFlatBuffer(), ChunkIter::num_elems, ChunkIter::second_buf, ChunkIter::skip_size, ChunkIter::start_pos, ChunkIter::type_info, and VarlenArray_get_nth().

                                                                                       {
   if (FlatBufferManager::isFlatBuffer(it)) {
     VarlenArray_get_nth(reinterpret_cast<int8_t*>(it), n, result, is_end);
     return;
   }
   if (!it || static_cast<size_t>(n) >= it->num_elems || n < 0) {
     *is_end = true;
     result->length = 0;
     result->pointer = NULL;
     result->is_null = true;
     return;
   }
   *is_end = false;
 
   if (it->skip_size > 0) {
     // for fixed-size
     int8_t* current_pos = it->start_pos + n * it->skip_size;
     result->length = static_cast<size_t>(it->skip_size);
     result->pointer = current_pos;
     bool is_null = false;
     if (!it->type_info.get_notnull()) {
       // Nulls can only be recognized when iterating over a !notnull-typed chunk
       is_null = it->type_info.is_null_fixlen_array(result->pointer, result->length);
     }
     result->is_null = is_null;
   } else {
     int8_t* current_pos = it->start_pos + n * sizeof(ArrayOffsetT);
     int8_t* next_pos = current_pos + sizeof(ArrayOffsetT);
     ArrayOffsetT offset = *(ArrayOffsetT*)current_pos;
     ArrayOffsetT next_offset = *(ArrayOffsetT*)next_pos;
     if (next_offset < 0) {  // Encoded NULL array
       result->length = 0;
       result->pointer = NULL;
       result->is_null = true;
     } else {
       if (offset < 0) {
         offset = -offset;  // Previous array may have been NULL, remove negativity
       }
       result->length = static_cast<size_t>(next_offset - offset);
       result->pointer = it->second_buf + offset;
       result->is_null = false;
     }
   }
 }

Here is the call graph for this function:

DEVICE void ChunkIter_get_nth_point_coords	(	ChunkIter *	it,
		int	n,
		ArrayDatum *	result,
		bool *	is_end
	)

Definition at line 321 of file ChunkIter.cpp.

References SQLTypeInfo::get_notnull(), is_null(), SQLTypeInfo::is_null_point_coord_array(), ChunkIter::num_elems, ChunkIter::skip_size, ChunkIter::start_pos, and ChunkIter::type_info.

                                                          {
   if (!it || static_cast<size_t>(n) >= it->num_elems || n < 0) {
     *is_end = true;
     result->length = 0;
     result->pointer = NULL;
     result->is_null = true;
     return;
   }
   *is_end = false;
 
   assert(it->skip_size > 0);
   int8_t* current_pos = it->start_pos + n * it->skip_size;
   result->length = static_cast<size_t>(it->skip_size);
   result->pointer = current_pos;
   bool is_null = false;
   if (!it->type_info.get_notnull()) {
     // Nulls can only be recognized when iterating over a !notnull-typed chunk
     is_null = it->type_info.is_null_point_coord_array(result->pointer, result->length);
   }
   result->is_null = is_null;
 }

Here is the call graph for this function:

DEVICE void ChunkIter_get_nth_varlen	(	ChunkIter *	it,
		int	n,
		ArrayDatum *	result,
		bool *	is_end
	)

Definition at line 267 of file ChunkIter.cpp.

References FlatBufferManager::isFlatBuffer(), anonymous_namespace{Utm.h}::n, ChunkIter::num_elems, ChunkIter::second_buf, ChunkIter::start_pos, and VarlenArray_get_nth().

                                                    {
   if (FlatBufferManager::isFlatBuffer(it)) {
     VarlenArray_get_nth(reinterpret_cast<int8_t*>(it), n, result, is_end);
     return;
   }
   *is_end = (!it || static_cast<size_t>(n) >= it->num_elems || n < 0);
 
   if (!*is_end) {
     int8_t* current_pos = it->start_pos + n * sizeof(ArrayOffsetT);
     int8_t* next_pos = current_pos + sizeof(ArrayOffsetT);
     ArrayOffsetT offset = *(ArrayOffsetT*)current_pos;
     ArrayOffsetT next_offset = *(ArrayOffsetT*)next_pos;
 
     if (next_offset >= 0) {
       // Previous array may have been NULL, remove offset negativity
       if (offset < 0) {
         offset = -offset;
       }
       result->length = static_cast<size_t>(next_offset - offset);
       result->pointer = it->second_buf + offset;
       result->is_null = false;
       return;
     }
   }
   // Encoded NULL array or out of bounds
   result->length = 0;
   result->pointer = NULL;
   result->is_null = true;
 }

Here is the call graph for this function:

DEVICE void ChunkIter_get_nth_varlen_notnull	(	ChunkIter *	it,
		int	n,
		ArrayDatum *	result,
		bool *	is_end
	)

Definition at line 301 of file ChunkIter.cpp.

References anonymous_namespace{Utm.h}::n, ChunkIter::num_elems, ChunkIter::second_buf, and ChunkIter::start_pos.

                                                            {
   *is_end = (static_cast<size_t>(n) >= it->num_elems || n < 0);
 
   int8_t* current_pos = it->start_pos + n * sizeof(ArrayOffsetT);
   int8_t* next_pos = current_pos + sizeof(ArrayOffsetT);
   ArrayOffsetT offset = *(ArrayOffsetT*)current_pos;
   ArrayOffsetT next_offset = *(ArrayOffsetT*)next_pos;
 
   result->length = static_cast<size_t>(next_offset - offset);
   result->pointer = it->second_buf + offset;
   result->is_null = false;
 }

void ChunkIter_reset ( ChunkIter * it )

Definition at line 144 of file ChunkIter.cpp.

References ChunkIter::current_pos, and ChunkIter::start_pos.

                                     {
   it->current_pos = it->start_pos;
 }

static DEVICE void decompress	(	const SQLTypeInfo &	ti,
		int8_t *	compressed,
		VarlenDatum *	result,
		Datum *	datum
	)

static

Definition at line 27 of file ChunkIter.cpp.

References Datum::bigintval, SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_type(), Datum::intval, VarlenDatum::is_null, SQLTypeInfo::is_null(), kBIGINT, kDATE, kDECIMAL, kENCODING_DATE_IN_DAYS, kENCODING_DICT, kENCODING_DIFF, kENCODING_FIXED, kENCODING_NONE, kENCODING_RL, kENCODING_SPARSE, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, VarlenDatum::length, VarlenDatum::pointer, and Datum::smallintval.

Referenced by ChunkIter_get_next(), and ChunkIter_get_nth().

                                             {
   switch (ti.get_type()) {
     case kSMALLINT:
       result->length = sizeof(int16_t);
       result->pointer = (int8_t*)&datum->smallintval;
       switch (ti.get_compression()) {
         case kENCODING_FIXED:
           assert(ti.get_comp_param() == 8);
           datum->smallintval = (int16_t) * (int8_t*)compressed;
           break;
         case kENCODING_RL:
         case kENCODING_DIFF:
         case kENCODING_SPARSE:
           assert(false);
           break;
         default:
           assert(false);
       }
       break;
     case kINT:
       result->length = sizeof(int32_t);
       result->pointer = (int8_t*)&datum->intval;
       switch (ti.get_compression()) {
         case kENCODING_FIXED:
           switch (ti.get_comp_param()) {
             case 8:
               datum->intval = (int32_t) * (int8_t*)compressed;
               break;
             case 16:
               datum->intval = (int32_t) * (int16_t*)compressed;
               break;
             default:
               assert(false);
           }
           break;
         case kENCODING_RL:
         case kENCODING_DIFF:
         case kENCODING_SPARSE:
           assert(false);
           break;
         default:
           assert(false);
       }
       break;
     case kBIGINT:
     case kNUMERIC:
     case kDECIMAL:
       result->length = sizeof(int64_t);
       result->pointer = (int8_t*)&datum->bigintval;
       switch (ti.get_compression()) {
         case kENCODING_FIXED:
           switch (ti.get_comp_param()) {
             case 8:
               datum->bigintval = (int64_t) * (int8_t*)compressed;
               break;
             case 16:
               datum->bigintval = (int64_t) * (int16_t*)compressed;
               break;
             case 32:
               datum->bigintval = (int64_t) * (int32_t*)compressed;
               break;
             default:
               assert(false);
           }
           break;
         case kENCODING_RL:
         case kENCODING_DIFF:
         case kENCODING_SPARSE:
           assert(false);
           break;
         default:
           assert(false);
       }
       break;
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
       switch (ti.get_compression()) {
         case kENCODING_FIXED:
           datum->bigintval = (int64_t) * (int32_t*)compressed;
           break;
         case kENCODING_DATE_IN_DAYS:
           switch (ti.get_comp_param()) {
             case 0:
             case 32:
               datum->bigintval = (int64_t) * (int32_t*)compressed;
               break;
             case 16:
               datum->bigintval = (int64_t) * (int16_t*)compressed;
               break;
             default:
               assert(false);
               break;
           }
           break;
         case kENCODING_RL:
         case kENCODING_DIFF:
         case kENCODING_DICT:
         case kENCODING_SPARSE:
         case kENCODING_NONE:
           assert(false);
           break;
         default:
           assert(false);
       }
       result->length = sizeof(int64_t);
       result->pointer = (int8_t*)&datum->bigintval;
       break;
     default:
       assert(false);
   }
   result->is_null = ti.is_null(*datum);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Function Documentation