Classes
class	NullSentinelSupplier

Functions
template<typename LHT , typename RHT >
void	value_truncated (const LHT &lhs, const RHT &rhs)

template<typename T >
bool	is_null (const T &v, const SQLTypeInfo &t)

template<typename LHT , typename RHT >
bool	integer_setter (LHT &lhs, const RHT &rhs, const SQLTypeInfo &t)

int	get_element_size (const SQLTypeInfo &t)

bool	is_null_string_index (const int size, const int32_t sidx)

int32_t	get_string_index (void *ptr, const int size)

bool	set_string_index (void *ptr, const SQLTypeInfo &etype, int32_t sidx)

template<typename T >
static void	put_scalar (void *ndptr, const SQLTypeInfo &etype, const int esize, const T oval)

double	decimal_to_double (const SQLTypeInfo &otype, int64_t oval)

template<typename T >
void	put_scalar (void ndptr, const SQLTypeInfo &ntype, const T oval, const std::string col_name, const SQLTypeInfo otype=nullptr)

void	put_null (void *ndptr, const SQLTypeInfo &ntype, const std::string col_name)

void	put_null_array (void *ndptr, const SQLTypeInfo &ntype, const std::string col_name)

template<typename T >
bool	get_scalar (void *ndptr, const SQLTypeInfo &ntype, T &v)

template<typename T >
void	set_minmax (T &min, T &max, T const val)

template<typename T >
void	set_minmax (T &min, T &max, bool &null_flag, T const val, T null_sentinel)

Function Documentation

double anonymous_namespace{TypedDataAccessors.h}::decimal_to_double	(	const SQLTypeInfo &	otype,
		int64_t	oval
	)

inline

Definition at line 185 of file TypedDataAccessors.h.

References SQLTypeInfo::get_scale().

Referenced by put_scalar(), and Fragmenter_Namespace::InsertOrderFragmenter::updateColumn().

                                                                         {
   return oval / pow(10, otype.get_scale());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int anonymous_namespace{TypedDataAccessors.h}::get_element_size ( const SQLTypeInfo & t )

inline

Definition at line 67 of file TypedDataAccessors.h.

References SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_size(), SQLTypeInfo::get_subtype(), SQLTypeInfo::is_array(), SQLTypeInfo::is_string_array(), and kNULLT.

                                                   {
   if (t.is_string_array()) {
     return sizeof(int32_t);
   }
   if (!t.is_array()) {
     return t.get_size();
   }
   return SQLTypeInfo(t.get_subtype(),
                      t.get_dimension(),
                      t.get_scale(),
                      false,
                      t.get_compression(),
                      t.get_comp_param(),
                      kNULLT)
       .get_size();
 }

Here is the call graph for this function:

template<typename T >

bool anonymous_namespace{TypedDataAccessors.h}::get_scalar	(	void *	ndptr,
		const SQLTypeInfo &	ntype,
		T &	v
	)

inline

Definition at line 355 of file TypedDataAccessors.h.

References SQLTypeInfo::get_size(), get_string_index(), SQLTypeInfo::get_type(), inline_fp_null_value< double >(), inline_fp_null_value< float >(), is_null_string_index(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, and kTINYINT.

                                                                     {
   switch (ntype.get_type()) {
     case kBOOLEAN:
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
     case kNUMERIC:
     case kDECIMAL:
       switch (ntype.get_size()) {
         case 1:
           return inline_int_null_value<int8_t>() == (v = *(int8_t*)ndptr);
         case 2:
           return inline_int_null_value<int16_t>() == (v = *(int16_t*)ndptr);
         case 4:
           return inline_int_null_value<int32_t>() == (v = *(int32_t*)ndptr);
         case 8:
           return inline_int_null_value<int64_t>() == (v = *(int64_t*)ndptr);
           break;
         default:
           abort();
       }
       break;
     case kFLOAT:
       return inline_fp_null_value<float>() == (v = *(float*)ndptr);
     case kDOUBLE:
       return inline_fp_null_value<double>() == (v = *(double*)ndptr);
     case kTEXT:
       v = get_string_index(ndptr, ntype.get_size());
       return is_null_string_index(ntype.get_size(), v);
     default:
       abort();
   }
 }

Here is the call graph for this function:

int32_t anonymous_namespace{TypedDataAccessors.h}::get_string_index	(	void *	ptr,
		const int	size
	)

inline

Definition at line 97 of file TypedDataAccessors.h.

Referenced by get_scalar().

                                                            {
   switch (size) {
     case 1:
       return *(uint8_t*)ptr;
     case 2:
       return *(uint16_t*)ptr;
     case 4:
       return *(int32_t*)ptr;
     default:
       abort();
   }
 }

Here is the caller graph for this function:

template<typename LHT , typename RHT >

bool anonymous_namespace{TypedDataAccessors.h}::integer_setter	(	LHT &	lhs,
		const RHT &	rhs,
		const SQLTypeInfo &	t
	)

inline

Definition at line 59 of file TypedDataAccessors.h.

References is_null(), and value_truncated().

Referenced by put_scalar(), and set_string_index().

                                                                            {
   const int64_t r = is_null(rhs, t) ? inline_int_null_value<LHT>() : rhs;
   if ((lhs = r) != r) {
     value_truncated(lhs, r);
   }
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

bool anonymous_namespace{TypedDataAccessors.h}::is_null	(	const T &	v,
		const SQLTypeInfo &	t
	)

inline

Definition at line 40 of file TypedDataAccessors.h.

References SQLTypeInfo::get_logical_size().

                                                       {
   if (std::is_floating_point<T>::value) {
     return v == inline_fp_null_value<T>();
   }
   switch (t.get_logical_size()) {
     case 1:
       return v == inline_int_null_value<int8_t>();
     case 2:
       return v == inline_int_null_value<int16_t>();
     case 4:
       return v == inline_int_null_value<int32_t>();
     case 8:
       return v == inline_int_null_value<int64_t>();
     default:
       abort();
   }
 }

Here is the call graph for this function:

bool anonymous_namespace{TypedDataAccessors.h}::is_null_string_index	(	const int	size,
		const int32_t	sidx
	)

inline

Definition at line 84 of file TypedDataAccessors.h.

Referenced by get_scalar().

                                                                      {
   switch (size) {
     case 1:
       return sidx == inline_int_null_value<uint8_t>();
     case 2:
       return sidx == inline_int_null_value<uint16_t>();
     case 4:
       return sidx == inline_int_null_value<int32_t>();
     default:
       abort();
   }
 }

Here is the caller graph for this function:

void anonymous_namespace{TypedDataAccessors.h}::put_null	(	void *	ndptr,
		const SQLTypeInfo &	ntype,
		const std::string	col_name
	)

inline

this f is currently only for putting fixed-size data in place this f is not yet for putting var-size or dict-encoded data

Definition at line 254 of file TypedDataAccessors.h.

References CHECK, SQLTypeInfo::get_notnull(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), inline_fp_null_value< double >(), inline_fp_null_value< float >(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, and kTINYINT.

Referenced by RelAlgExecutor::executeSimpleInsert(), and Fragmenter_Namespace::InsertOrderFragmenter::updateColumn().

                                                                                       {
   if (ntype.get_notnull()) {
     throw std::runtime_error("NULL value on NOT NULL column '" + col_name + "'");
   }
 
   switch (ntype.get_type()) {
     case kBOOLEAN:
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
     case kNUMERIC:
     case kDECIMAL:
     case kTEXT:
       switch (ntype.get_size()) {
         case 1:
           *(int8_t*)ndptr = inline_int_null_value<int8_t>();
           break;
         case 2:
           *(int16_t*)ndptr = inline_int_null_value<int16_t>();
           break;
         case 4:
           *(int32_t*)ndptr = inline_int_null_value<int32_t>();
           break;
         case 8:
           *(int64_t*)ndptr = inline_int_null_value<int64_t>();
           break;
         default:
           abort();
       }
       break;
     case kFLOAT:
       *(float*)ndptr = inline_fp_null_value<float>();
       break;
     case kDOUBLE:
       *(double*)ndptr = inline_fp_null_value<double>();
       break;
     default:
       CHECK(false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{TypedDataAccessors.h}::put_null_array	(	void *	ndptr,
		const SQLTypeInfo &	ntype,
		const std::string	col_name
	)

inline

this f is currently only for putting fixed-size data in place this f is not yet for putting var-size or dict-encoded data

Definition at line 303 of file TypedDataAccessors.h.

References CHECK, SQLTypeInfo::get_notnull(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), inline_fp_null_array_value< double >(), inline_fp_null_array_value< float >(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, and kTINYINT.

Referenced by RelAlgExecutor::executeSimpleInsert().

                                                      {
   if (ntype.get_notnull()) {
     throw std::runtime_error("NULL value on NOT NULL column '" + col_name + "'");
   }
 
   switch (ntype.get_type()) {
     case kBOOLEAN:
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
     case kNUMERIC:
     case kDECIMAL:
     case kTEXT:
       switch (ntype.get_size()) {
         case 1:
           *(int8_t*)ndptr = inline_int_null_array_value<int8_t>();
           break;
         case 2:
           *(int16_t*)ndptr = inline_int_null_array_value<int16_t>();
           break;
         case 4:
           *(int32_t*)ndptr = inline_int_null_array_value<int32_t>();
           break;
         case 8:
           *(int64_t*)ndptr = inline_int_null_array_value<int64_t>();
           break;
         default:
           abort();
       }
       break;
     case kFLOAT:
       *(float*)ndptr = inline_fp_null_array_value<float>();
       break;
     case kDOUBLE:
       *(double*)ndptr = inline_fp_null_array_value<double>();
       break;
     default:
       CHECK(false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

static void anonymous_namespace{TypedDataAccessors.h}::put_scalar	(	void *	ndptr,
		const SQLTypeInfo &	etype,
		const int	esize,
		const T	oval
	)

static

Definition at line 127 of file TypedDataAccessors.h.

References SQLTypeInfo::get_type(), integer_setter(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timeinterval(), SQLTypeInfo::is_varlen(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, and set_string_index().

                                      {
   // round floating oval to nearest integer
   auto rval = oval;
   if (std::is_floating_point<T>::value) {
     if (etype.is_integer() || etype.is_time() || etype.is_timeinterval() ||
         etype.is_decimal()) {
       rval = round(rval);
     }
   }
   switch (etype.get_type()) {
     case kBOOLEAN:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
     case kNUMERIC:
     case kDECIMAL:
       switch (esize) {
         case 1:
           integer_setter(*(int8_t*)ndptr, rval, etype);
           break;
         case 2:
           integer_setter(*(int16_t*)ndptr, rval, etype);
           break;
         case 4:
           integer_setter(*(int32_t*)ndptr, rval, etype);
           break;
         case 8:
           integer_setter(*(int64_t*)ndptr, rval, etype);
           break;
         default:
           abort();
       }
       break;
     case kFLOAT:
       *(float*)ndptr = rval;
       break;
     case kDOUBLE:
       *(double*)ndptr = rval;
       break;
     default:
       if (etype.is_string() && !etype.is_varlen()) {
         set_string_index(ndptr, etype, rval);
       } else {
         abort();
       }
       break;
   }
 }

Here is the call graph for this function:

template<typename T >

void anonymous_namespace{TypedDataAccessors.h}::put_scalar	(	void *	ndptr,
		const SQLTypeInfo &	ntype,
		const T	oval,
		const std::string	col_name,
		const SQLTypeInfo *	otype = `nullptr`
	)

inline

Definition at line 190 of file TypedDataAccessors.h.

References convert_decimal_value_to_scale(), decimal_to_double(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_element_size(), DateConverters::get_epoch_days_from_seconds(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_subtype(), SQLTypeInfo::is_array(), is_null(), kDATE, kDECIMAL, kNULLT, and kNUMERIC.

                                                            {
   const auto& etype = ntype.is_array() ? SQLTypeInfo(ntype.get_subtype(),
                                                      ntype.get_dimension(),
                                                      ntype.get_scale(),
                                                      ntype.get_notnull(),
                                                      ntype.get_compression(),
                                                      ntype.get_comp_param(),
                                                      kNULLT)
                                        : ntype;
   const auto esize = get_element_size(etype);
   const auto isnull = is_null(oval, etype);
   if (etype.get_notnull() && isnull) {
     throw std::runtime_error("NULL value on NOT NULL column '" + col_name + "'");
   }
 
   switch (etype.get_type()) {
     case kNUMERIC:
     case kDECIMAL:
       if (otype && otype->is_decimal()) {
         put_scalar<int64_t>(ndptr,
                             etype,
                             esize,
                             isnull ? inline_int_null_value<int64_t>()
                                    : convert_decimal_value_to_scale(oval, *otype, etype));
       } else {
         put_scalar<T>(ndptr,
                       etype,
                       esize,
                       isnull ? inline_int_null_value<int64_t>()
                              : oval * pow(10, etype.get_scale()));
       }
       break;
     case kDATE:
       // For small dates, we store in days but decode in seconds
       // therefore we have to scale the decoded value in order to
       // make value storable.
       // Should be removed when we refactor code to use DateConverterFactory
       // from TargetValueConverterFactories so that we would
       // have everything in one place.
       if (etype.is_date_in_days()) {
         put_scalar<T>(ndptr,
                       etype,
                       get_element_size(etype),
                       isnull ? inline_int_null_value<int64_t>()
                              : DateConverters::get_epoch_days_from_seconds(
                                    static_cast<int64_t>(oval)));
       } else {
         put_scalar<T>(ndptr, etype, get_element_size(etype), oval);
       }
       break;
     default:
       if (otype && otype->is_decimal()) {
         put_scalar<double>(ndptr, etype, decimal_to_double(*otype, oval), col_name);
       } else {
         put_scalar<T>(ndptr, etype, get_element_size(etype), oval);
       }
       break;
   }
 }

Here is the call graph for this function:

template<typename T >

void anonymous_namespace{TypedDataAccessors.h}::set_minmax	(	T &	min,
		T &	max,
		T const	val
	)

inline

Definition at line 422 of file TypedDataAccessors.h.

Referenced by Fragmenter_Namespace::set_chunk_stats(), and Fragmenter_Namespace::anonymous_namespace{UpdelStorage.cpp}::update_metadata().

                                                     {
   if (val < min) {
     min = val;
   }
   if (val > max) {
     max = val;
   }
 }

Here is the caller graph for this function:

template<typename T >

void anonymous_namespace{TypedDataAccessors.h}::set_minmax	(	T &	min,
		T &	max,
		bool &	null_flag,
		T const	val,
		T	null_sentinel
	)

inline

Definition at line 432 of file TypedDataAccessors.h.

                                                                                       {
   if (val == null_sentinel) {
     null_flag = true;
   } else {
     if (val < min) {
       min = val;
     }
     if (val > max) {
       max = val;
     }
   }
 }

bool anonymous_namespace{TypedDataAccessors.h}::set_string_index	(	void *	ptr,
		const SQLTypeInfo &	etype,
		int32_t	sidx
	)

inline

Definition at line 110 of file TypedDataAccessors.h.

References anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_element_size(), and integer_setter().

Referenced by put_scalar().

                                                                                 {
   switch (get_element_size(etype)) {
     case 1:
       return integer_setter(*(uint8_t*)ptr, sidx, etype);
       break;
     case 2:
       return integer_setter(*(uint16_t*)ptr, sidx, etype);
       break;
     case 4:
       return integer_setter(*(int32_t*)ptr, sidx, etype);
       break;
     default:
       abort();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename LHT , typename RHT >

void anonymous_namespace{TypedDataAccessors.h}::value_truncated	(	const LHT &	lhs,
		const RHT &	rhs
	)

inline

Definition at line 30 of file TypedDataAccessors.h.

Referenced by integer_setter().

                                                             {
   std::ostringstream os;
   os << "Value " << rhs << " would be truncated to "
      << (std::is_same<LHT, uint8_t>::value || std::is_same<LHT, int8_t>::value
              ? (int64_t)lhs
              : lhs);
   throw std::runtime_error(os.str());
 };

Here is the caller graph for this function:

Classes

Functions

Function Documentation