OmniSciDB  8a228a1076
sqltypes.h File Reference

Constants for Builtin SQL Types supported by OmniSci. More...

#include "Logger/Logger.h"
#include "StringTransform.h"
#include "funcannotations.h"
#include <cassert>
#include <cfloat>
#include <cstdint>
#include <ctime>
#include <limits>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include <string_view>
#include "../QueryEngine/DateAdd.h"
#include "../QueryEngine/DateTruncate.h"
#include "../QueryEngine/ExtractFromTime.h"
#include "InlineNullValues.h"
+ Include dependency graph for sqltypes.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  VarlenDatum
 
struct  DoNothingDeleter
 
struct  FreeDeleter
 
struct  HostArrayDatum
 
struct  DeviceArrayDatum
 
union  Datum
 
union  DataBlockPtr
 
class  SQLTypeInfo
 

Macros

#define IS_INTEGER(T)   (((T) == kINT) || ((T) == kSMALLINT) || ((T) == kBIGINT) || ((T) == kTINYINT))
 
#define IS_NUMBER(T)
 
#define IS_STRING(T)   (((T) == kTEXT) || ((T) == kVARCHAR) || ((T) == kCHAR))
 
#define IS_GEO(T)   (((T) == kPOINT) || ((T) == kLINESTRING) || ((T) == kPOLYGON) || ((T) == kMULTIPOLYGON))
 
#define IS_INTERVAL(T)   ((T) == kINTERVAL_DAY_TIME || (T) == kINTERVAL_YEAR_MONTH)
 
#define IS_DECIMAL(T)   ((T) == kNUMERIC || (T) == kDECIMAL)
 
#define IS_GEO_POLY(T)   (((T) == kPOLYGON) || ((T) == kMULTIPOLYGON))
 
#define NULL_BOOLEAN   INT8_MIN
 
#define NULL_TINYINT   INT8_MIN
 
#define NULL_SMALLINT   INT16_MIN
 
#define NULL_INT   INT32_MIN
 
#define NULL_BIGINT   INT64_MIN
 
#define NULL_FLOAT   FLT_MIN
 
#define NULL_DOUBLE   DBL_MIN
 
#define NULL_ARRAY_BOOLEAN   (INT8_MIN + 1)
 
#define NULL_ARRAY_TINYINT   (INT8_MIN + 1)
 
#define NULL_ARRAY_SMALLINT   (INT16_MIN + 1)
 
#define NULL_ARRAY_INT   (INT32_MIN + 1)
 
#define NULL_ARRAY_BIGINT   (INT64_MIN + 1)
 
#define NULL_ARRAY_FLOAT   (FLT_MIN * 2.0)
 
#define NULL_ARRAY_DOUBLE   (DBL_MIN * 2.0)
 
#define NULL_ARRAY_COMPRESSED_32   0x80000000U
 
#define TRANSIENT_DICT_ID   0
 
#define TRANSIENT_DICT(ID)   (-(ID))
 
#define REGULAR_DICT(TRANSIENTID)   (-(TRANSIENTID))
 

Typedefs

using ArrayDatum = std::conditional_t< is_cuda_compiler(), DeviceArrayDatum, HostArrayDatum >
 
using StringOffsetT = int32_t
 
using ArrayOffsetT = int32_t
 

Enumerations

enum  SQLTypes {
  kNULLT = 0, kBOOLEAN = 1, kCHAR = 2, kVARCHAR = 3,
  kNUMERIC = 4, kDECIMAL = 5, kINT = 6, kSMALLINT = 7,
  kFLOAT = 8, kDOUBLE = 9, kTIME = 10, kTIMESTAMP = 11,
  kBIGINT = 12, kTEXT = 13, kDATE = 14, kARRAY = 15,
  kINTERVAL_DAY_TIME = 16, kINTERVAL_YEAR_MONTH = 17, kPOINT = 18, kLINESTRING = 19,
  kPOLYGON = 20, kMULTIPOLYGON = 21, kTINYINT = 22, kGEOMETRY = 23,
  kGEOGRAPHY = 24, kEVAL_CONTEXT_TYPE = 25, kVOID = 26, kCURSOR = 27,
  kCOLUMN = 28, kSQLTYPE_LAST = 29
}
 
enum  EncodingType {
  kENCODING_NONE = 0, kENCODING_FIXED = 1, kENCODING_RL = 2, kENCODING_DIFF = 3,
  kENCODING_DICT = 4, kENCODING_SPARSE = 5, kENCODING_GEOINT = 6, kENCODING_DATE_IN_DAYS = 7,
  kENCODING_LAST = 8
}
 

Functions

DEVICE constexpr bool is_cuda_compiler ()
 
constexpr auto is_datetime (SQLTypes type)
 
SQLTypes decimal_to_int_type (const SQLTypeInfo &)
 
Datum StringToDatum (std::string_view s, SQLTypeInfo &ti)
 
std::string DatumToString (Datum d, const SQLTypeInfo &ti)
 
bool DatumEqual (const Datum, const Datum, const SQLTypeInfo &ti)
 
int64_t convert_decimal_value_to_scale (const int64_t decimal_value, const SQLTypeInfo &type_info, const SQLTypeInfo &new_type_info)
 
SQLTypeInfo get_logical_type_info (const SQLTypeInfo &type_info)
 
SQLTypeInfo get_nullable_type_info (const SQLTypeInfo &type_info)
 
SQLTypeInfo get_nullable_logical_type_info (const SQLTypeInfo &type_info)
 
template<class T >
constexpr int64_t inline_int_null_value ()
 
template<class T >
constexpr int64_t inline_int_null_array_value ()
 
template<class T >
constexpr int64_t max_valid_int_value ()
 
int8_t * appendDatum (int8_t *buf, Datum d, const SQLTypeInfo &ti)
 

Detailed Description

Constants for Builtin SQL Types supported by OmniSci.

Author
Wei Hong wei@m.nosp@m.ap-d.nosp@m..com

Definition in file sqltypes.h.

Macro Definition Documentation

◆ IS_DECIMAL

#define IS_DECIMAL (   T)    ((T) == kNUMERIC || (T) == kDECIMAL)

Definition at line 177 of file sqltypes.h.

◆ IS_GEO

◆ IS_GEO_POLY

#define IS_GEO_POLY (   T)    (((T) == kPOLYGON) || ((T) == kMULTIPOLYGON))

◆ IS_INTEGER

#define IS_INTEGER (   T)    (((T) == kINT) || ((T) == kSMALLINT) || ((T) == kBIGINT) || ((T) == kTINYINT))

◆ IS_INTERVAL

#define IS_INTERVAL (   T)    ((T) == kINTERVAL_DAY_TIME || (T) == kINTERVAL_YEAR_MONTH)

Definition at line 176 of file sqltypes.h.

Referenced by SQLTypeInfo::is_timeinterval().

◆ IS_NUMBER

#define IS_NUMBER (   T)
Value:
(((T) == kINT) || ((T) == kSMALLINT) || ((T) == kDOUBLE) || ((T) == kFLOAT) || \
((T) == kBIGINT) || ((T) == kNUMERIC) || ((T) == kDECIMAL) || ((T) == kTINYINT))
Definition: sqltypes.h:47

Definition at line 170 of file sqltypes.h.

Referenced by SQLTypeInfo::is_number(), and anonymous_namespace{EquiJoinCondition.cpp}::make_composite_equals_impl().

◆ IS_STRING

◆ NULL_ARRAY_BIGINT

#define NULL_ARRAY_BIGINT   (INT64_MIN + 1)

◆ NULL_ARRAY_BOOLEAN

#define NULL_ARRAY_BOOLEAN   (INT8_MIN + 1)

Definition at line 188 of file sqltypes.h.

Referenced by FixedLengthArrayNoneEncoder::is_null().

◆ NULL_ARRAY_COMPRESSED_32

#define NULL_ARRAY_COMPRESSED_32   0x80000000U

Definition at line 196 of file sqltypes.h.

Referenced by SQLTypeInfo::is_null_point_coord_array().

◆ NULL_ARRAY_DOUBLE

◆ NULL_ARRAY_FLOAT

#define NULL_ARRAY_FLOAT   (FLT_MIN * 2.0)

◆ NULL_ARRAY_INT

#define NULL_ARRAY_INT   (INT32_MIN + 1)

◆ NULL_ARRAY_SMALLINT

#define NULL_ARRAY_SMALLINT   (INT16_MIN + 1)

◆ NULL_ARRAY_TINYINT

#define NULL_ARRAY_TINYINT   (INT8_MIN + 1)

◆ NULL_BIGINT

◆ NULL_BOOLEAN

◆ NULL_DOUBLE

#define NULL_DOUBLE   DBL_MIN

Definition at line 186 of file sqltypes.h.

Referenced by import_export::TypedImportBuffer::add_value(), import_export::TypedImportBuffer::add_values(), Parser::InsertValuesStmt::analyze(), CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenIsNullNumber(), geospatial::compress_null_point(), GeoPointValueConverter::convertToColumnarFormat(), GeoLinestringValueConverter::convertToColumnarFormat(), GeoPolygonValueConverter::convertToColumnarFormat(), GeoMultiPolygonValueConverter::convertToColumnarFormat(), import_export::QueryExporterCSV::exportResults(), float_to_double_bin(), Geo_namespace::GeoPoint::getColumns(), Geo_namespace::GeoLineString::getColumns(), Geo_namespace::GeoPolygon::getColumns(), Geo_namespace::GeoMultiPolygon::getColumns(), Geo_namespace::GeoTypesFactory::getNullGeoColumns(), inline_fp_null_value< double >(), CgenState::inlineFpNull(), import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_array_column(), import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_scalar_column(), SQLTypeInfo::is_null(), Analyzer::anonymous_namespace{Analyzer.cpp}::is_null_value(), ResultSet::isNull(), ResultSet::makeTargetValue(), import_export::NullDatum(), import_export::Importer::set_geo_physical_import_buffer(), import_export::Importer::set_geo_physical_import_buffer_columnar(), Analyzer::Constant::set_null_value(), import_export::TDatumToDatum(), FixedLengthArrayNoneEncoder::update_elem_stats(), ArrayNoneEncoder::update_elem_stats(), DBHandler::value_to_thrift(), and DBHandler::value_to_thrift_column().

◆ NULL_FLOAT

◆ NULL_INT

◆ NULL_SMALLINT

◆ NULL_TINYINT

◆ REGULAR_DICT

#define REGULAR_DICT (   TRANSIENTID)    (-(TRANSIENTID))

Definition at line 200 of file sqltypes.h.

Referenced by Executor::getStringDictionaryProxy().

◆ TRANSIENT_DICT

◆ TRANSIENT_DICT_ID

Typedef Documentation

◆ ArrayDatum

Definition at line 131 of file sqltypes.h.

◆ ArrayOffsetT

using ArrayOffsetT = int32_t

Definition at line 868 of file sqltypes.h.

◆ StringOffsetT

using StringOffsetT = int32_t

Definition at line 867 of file sqltypes.h.

Enumeration Type Documentation

◆ EncodingType

Enumerator
kENCODING_NONE 
kENCODING_FIXED 
kENCODING_RL 
kENCODING_DIFF 
kENCODING_DICT 
kENCODING_SPARSE 
kENCODING_GEOINT 
kENCODING_DATE_IN_DAYS 
kENCODING_LAST 

Definition at line 156 of file sqltypes.h.

156  {
157  kENCODING_NONE = 0, // no encoding
158  kENCODING_FIXED = 1, // Fixed-bit encoding
159  kENCODING_RL = 2, // Run Length encoding
160  kENCODING_DIFF = 3, // Differential encoding
161  kENCODING_DICT = 4, // Dictionary encoding
162  kENCODING_SPARSE = 5, // Null encoding for sparse columns
163  kENCODING_GEOINT = 6, // Encoding coordinates as intergers
164  kENCODING_DATE_IN_DAYS = 7, // Date encoding in days
165  kENCODING_LAST = 8
166 };

◆ SQLTypes

enum SQLTypes
Enumerator
kNULLT 
kBOOLEAN 
kCHAR 
kVARCHAR 
kNUMERIC 
kDECIMAL 
kINT 
kSMALLINT 
kFLOAT 
kDOUBLE 
kTIME 
kTIMESTAMP 
kBIGINT 
kTEXT 
kDATE 
kARRAY 
kINTERVAL_DAY_TIME 
kINTERVAL_YEAR_MONTH 
kPOINT 
kLINESTRING 
kPOLYGON 
kMULTIPOLYGON 
kTINYINT 
kGEOMETRY 
kGEOGRAPHY 
kEVAL_CONTEXT_TYPE 
kVOID 
kCURSOR 
kCOLUMN 
kSQLTYPE_LAST 

Definition at line 40 of file sqltypes.h.

40  {
41  kNULLT = 0, // type for null values
42  kBOOLEAN = 1,
43  kCHAR = 2,
44  kVARCHAR = 3,
45  kNUMERIC = 4,
46  kDECIMAL = 5,
47  kINT = 6,
48  kSMALLINT = 7,
49  kFLOAT = 8,
50  kDOUBLE = 9,
51  kTIME = 10,
52  kTIMESTAMP = 11,
53  kBIGINT = 12,
54  kTEXT = 13,
55  kDATE = 14,
56  kARRAY = 15,
57  kINTERVAL_DAY_TIME = 16,
59  kPOINT = 18,
60  kLINESTRING = 19,
61  kPOLYGON = 20,
62  kMULTIPOLYGON = 21,
63  kTINYINT = 22,
64  kGEOMETRY = 23,
65  kGEOGRAPHY = 24,
66  kEVAL_CONTEXT_TYPE = 25, // Placeholder Type for ANY
67  kVOID = 26,
68  kCURSOR = 27,
69  kCOLUMN = 28,
70  kSQLTYPE_LAST = 29
71 };
Definition: sqltypes.h:51
Definition: sqltypes.h:67
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:43
Definition: sqltypes.h:47

Function Documentation

◆ appendDatum()

int8_t* appendDatum ( int8_t *  buf,
Datum  d,
const SQLTypeInfo ti 
)
inline

Definition at line 870 of file sqltypes.h.

References Datum::bigintval, Datum::boolval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), Datum::intval, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, Datum::smallintval, and Datum::tinyintval.

Referenced by RelAlgExecutor::executeSimpleInsert(), import_export::NullArray(), import_export::StringToArray(), and import_export::TDatumToArrayDatum().

870  {
871  switch (ti.get_type()) {
872  case kBOOLEAN:
873  *(bool*)buf = d.boolval;
874  return buf + sizeof(bool);
875  case kNUMERIC:
876  case kDECIMAL:
877  case kBIGINT:
878  *(int64_t*)buf = d.bigintval;
879  return buf + sizeof(int64_t);
880  case kINT:
881  *(int32_t*)buf = d.intval;
882  return buf + sizeof(int32_t);
883  case kSMALLINT:
884  *(int16_t*)buf = d.smallintval;
885  return buf + sizeof(int16_t);
886  case kTINYINT:
887  *(int8_t*)buf = d.tinyintval;
888  return buf + sizeof(int8_t);
889  case kFLOAT:
890  *(float*)buf = d.floatval;
891  return buf + sizeof(float);
892  case kDOUBLE:
893  *(double*)buf = d.doubleval;
894  return buf + sizeof(double);
895  case kTIME:
896  case kTIMESTAMP:
897  case kDATE:
898  *reinterpret_cast<int64_t*>(buf) = d.bigintval;
899  return buf + sizeof(int64_t);
900  default:
901  return nullptr;
902  }
903 }
int8_t tinyintval
Definition: sqltypes.h:135
Definition: sqltypes.h:51
bool boolval
Definition: sqltypes.h:134
int32_t intval
Definition: sqltypes.h:137
float floatval
Definition: sqltypes.h:139
int64_t bigintval
Definition: sqltypes.h:138
int16_t smallintval
Definition: sqltypes.h:136
Definition: sqltypes.h:55
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
Definition: sqltypes.h:47
double doubleval
Definition: sqltypes.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ convert_decimal_value_to_scale()

int64_t convert_decimal_value_to_scale ( const int64_t  decimal_value,
const SQLTypeInfo type_info,
const SQLTypeInfo new_type_info 
)

Definition at line 315 of file Datum.cpp.

References SQLTypeInfo::get_scale().

Referenced by import_export::TypedImportBuffer::add_value(), Analyzer::Constant::cast_number(), SQLTypeInfo::get_storage_size(), anonymous_namespace{ArrowImporter.h}::ArrowValue< arrow::Decimal128 >::operator const DATA_TYPE(), and anonymous_namespace{TypedDataAccessors.h}::put_scalar().

317  {
318  auto converted_decimal_value = decimal_value;
319  if (new_type_info.get_scale() > type_info.get_scale()) {
320  for (int i = 0; i < new_type_info.get_scale() - type_info.get_scale(); i++) {
321  converted_decimal_value *= 10;
322  }
323  } else if (new_type_info.get_scale() < type_info.get_scale()) {
324  for (int i = 0; i < type_info.get_scale() - new_type_info.get_scale(); i++) {
325  if (converted_decimal_value > 0) {
326  converted_decimal_value = (converted_decimal_value + 5) / 10;
327  } else {
328  converted_decimal_value = (converted_decimal_value - 5) / 10;
329  }
330  }
331  }
332  return converted_decimal_value;
333 }
HOST DEVICE int get_scale() const
Definition: sqltypes.h:264
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ DatumEqual()

bool DatumEqual ( const Datum  ,
const Datum  ,
const SQLTypeInfo ti 
)

Definition at line 190 of file Datum.cpp.

References Datum::bigintval, Datum::boolval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_compression(), SQLTypeInfo::get_type(), Datum::intval, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kENCODING_DICT, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::stringval, and Datum::tinyintval.

Referenced by SQLTypeInfo::get_storage_size(), and ChunkMetadata::operator==().

190  {
191  switch (ti.get_type()) {
192  case kBOOLEAN:
193  return a.boolval == b.boolval;
194  case kBIGINT:
195  case kNUMERIC:
196  case kDECIMAL:
197  return a.bigintval == b.bigintval;
198  case kINT:
199  return a.intval == b.intval;
200  case kSMALLINT:
201  return a.smallintval == b.smallintval;
202  case kTINYINT:
203  return a.tinyintval == b.tinyintval;
204  case kFLOAT:
205  return a.floatval == b.floatval;
206  case kDOUBLE:
207  return a.doubleval == b.doubleval;
208  case kTIME:
209  case kTIMESTAMP:
210  case kDATE:
211  case kINTERVAL_DAY_TIME:
213  return a.bigintval == b.bigintval;
214  case kTEXT:
215  case kVARCHAR:
216  case kCHAR:
217  if (ti.get_compression() == kENCODING_DICT) {
218  return a.intval == b.intval;
219  }
220  if (a.stringval == nullptr && b.stringval == nullptr) {
221  return true;
222  }
223  if (a.stringval == nullptr || b.stringval == nullptr) {
224  return false;
225  }
226  return *a.stringval == *b.stringval;
227  default:
228  return false;
229  }
230  return false;
231 }
Definition: sqltypes.h:51
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:267
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:43
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
Definition: sqltypes.h:47
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ DatumToString()

std::string DatumToString ( Datum  d,
const SQLTypeInfo ti 
)

Definition at line 236 of file Datum.cpp.

References Datum::bigintval, Datum::boolval, CHECK_EQ, CHECK_LE, Datum::doubleval, Datum::floatval, shared::formatDate(), shared::formatDateTime(), shared::formatHMS(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Datum::intval, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::stringval, Datum::tinyintval, and to_string().

Referenced by Analyzer::Constant::cast_to_string(), datum_to_string(), ChunkMetadata::dump(), SQLTypeInfo::get_storage_size(), anonymous_namespace{ArrowImporter.h}::ArrowValue< int64_t >::operator const std::string(), Analyzer::Constant::toString(), Fragmenter_Namespace::InsertOrderFragmenter::updateChunkStats(), and ScalarExprToSql::visitConstant().

236  {
237  constexpr size_t buf_size = 32;
238  char buf[buf_size]; // Hold "2000-03-01 12:34:56.123456789" and large years.
239  switch (ti.get_type()) {
240  case kBOOLEAN:
241  if (d.boolval) {
242  return "t";
243  }
244  return "f";
245  case kNUMERIC:
246  case kDECIMAL: {
247  // we need to consider buf_size including the scale and null terminator
248  char str[ti.get_dimension() + ti.get_scale() + 2];
249  double v = (double)d.bigintval / pow(10, ti.get_scale());
250  sprintf(str, "%*.*f", ti.get_dimension(), ti.get_scale(), v);
251  return std::string(str);
252  }
253  case kINT:
254  return std::to_string(d.intval);
255  case kSMALLINT:
256  return std::to_string(d.smallintval);
257  case kTINYINT:
258  return std::to_string(d.tinyintval);
259  case kBIGINT:
260  return std::to_string(d.bigintval);
261  case kFLOAT:
262  return std::to_string(d.floatval);
263  case kDOUBLE:
264  return std::to_string(d.doubleval);
265  case kTIME: {
266  size_t const len = shared::formatHMS(buf, buf_size, d.bigintval);
267  CHECK_EQ(8u, len); // 8 == strlen("HH:MM:SS")
268  return buf;
269  }
270  case kTIMESTAMP: {
271  unsigned const dim = ti.get_dimension(); // assumes dim <= 9
272  size_t const len = shared::formatDateTime(buf, buf_size, d.bigintval, dim);
273  CHECK_LE(19u + bool(dim) + dim, len); // 19 = strlen("YYYY-MM-DD HH:MM:SS")
274  return buf;
275  }
276  case kDATE: {
277  size_t const len = shared::formatDate(buf, buf_size, d.bigintval);
278  CHECK_LE(10u, len); // 10 == strlen("YYYY-MM-DD")
279  return buf;
280  }
281  case kINTERVAL_DAY_TIME:
282  return std::to_string(d.bigintval) + " ms (day-time interval)";
284  return std::to_string(d.bigintval) + " month(s) (year-month interval)";
285  case kTEXT:
286  case kVARCHAR:
287  case kCHAR:
288  if (d.stringval == nullptr) {
289  return "NULL";
290  }
291  return *d.stringval;
292  default:
293  throw std::runtime_error("Internal error: invalid type " + ti.get_type_name() +
294  " in DatumToString.");
295  }
296  return "";
297 }
int8_t tinyintval
Definition: sqltypes.h:135
#define CHECK_EQ(x, y)
Definition: Logger.h:205
Definition: sqltypes.h:51
bool boolval
Definition: sqltypes.h:134
size_t formatDateTime(char *buf, size_t const max, int64_t const timestamp, int const dimension)
Definition: misc.cpp:42
int32_t intval
Definition: sqltypes.h:137
HOST DEVICE int get_scale() const
Definition: sqltypes.h:264
std::string to_string(char const *&&v)
size_t formatHMS(char *buf, size_t const max, int64_t const unixtime)
Definition: misc.cpp:78
float floatval
Definition: sqltypes.h:139
int64_t bigintval
Definition: sqltypes.h:138
int16_t smallintval
Definition: sqltypes.h:136
std::string * stringval
Definition: sqltypes.h:143
size_t formatDate(char *buf, size_t const max, int64_t const unixtime)
Definition: misc.cpp:25
Definition: sqltypes.h:54
Definition: sqltypes.h:55
#define CHECK_LE(x, y)
Definition: Logger.h:208
std::string get_type_name() const
Definition: sqltypes.h:362
HOST DEVICE int get_dimension() const
Definition: sqltypes.h:261
Definition: sqltypes.h:43
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
Definition: sqltypes.h:47
double doubleval
Definition: sqltypes.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ decimal_to_int_type()

SQLTypes decimal_to_int_type ( const SQLTypeInfo )

Definition at line 299 of file Datum.cpp.

References CHECK, SQLTypeInfo::get_size(), kBIGINT, kINT, kNULLT, kSMALLINT, and kTINYINT.

Referenced by import_export::TypedImportBuffer::add_value(), CodeGenerator::codegen(), CodeGenerator::codegenIntConst(), anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division(), import_export::Loader::distributeToShards(), extract_from_datum(), anonymous_namespace{ColumnIR.cpp}::get_col_decoder(), SQLTypeInfo::get_storage_size(), CgenState::getOrAddLiteral(), ResultSet::makeTargetValue(), import_export::NullArrayDatum(), import_export::NullDatum(), import_export::TypedImportBuffer::pop_value(), import_export::TDatumToDatum(), anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitBinOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitUOper().

299  {
300  switch (ti.get_size()) {
301  case 1:
302  return kTINYINT;
303  case 2:
304  return kSMALLINT;
305  case 4:
306  return kINT;
307  case 8:
308  return kBIGINT;
309  default:
310  CHECK(false);
311  }
312  return kNULLT;
313 }
#define CHECK(condition)
Definition: Logger.h:197
Definition: sqltypes.h:47
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_logical_type_info()

SQLTypeInfo get_logical_type_info ( const SQLTypeInfo type_info)
inline

Definition at line 819 of file sqltypes.h.

References SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), kARRAY, kENCODING_DATE_IN_DAYS, kENCODING_FIXED, and kENCODING_NONE.

Referenced by anonymous_namespace{ColumnarResults.cpp}::fixed_encoding_nullable_val(), anonymous_namespace{RelAlgExecutor.cpp}::get_logical_type_for_expr(), anonymous_namespace{TypedDataAccessors.h}::NullSentinelSupplier::get_null_sentinel_for_type(), get_nullable_logical_type_info(), get_target_info(), JoinHashTable::getHashJoinArgs(), getLeafColumnRange(), Parser::CaseExpr::normalize(), TableOptimizer::recomputeMetadata(), rows_to_columnar_results(), Fragmenter_Namespace::InsertOrderFragmenter::updateChunkStats(), and Fragmenter_Namespace::InsertOrderFragmenter::updateColumns().

819  {
820  EncodingType encoding = type_info.get_compression();
821  if (encoding == kENCODING_DATE_IN_DAYS ||
822  (encoding == kENCODING_FIXED && type_info.get_type() != kARRAY)) {
823  encoding = kENCODING_NONE;
824  }
825  return SQLTypeInfo(type_info.get_type(),
826  type_info.get_dimension(),
827  type_info.get_scale(),
828  type_info.get_notnull(),
829  encoding,
830  type_info.get_comp_param(),
831  type_info.get_subtype());
832 }
HOST DEVICE int get_comp_param() const
Definition: sqltypes.h:268
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:267
HOST DEVICE int get_scale() const
Definition: sqltypes.h:264
HOST DEVICE bool get_notnull() const
Definition: sqltypes.h:266
EncodingType
Definition: sqltypes.h:156
HOST DEVICE SQLTypes get_subtype() const
Definition: sqltypes.h:260
HOST DEVICE int get_dimension() const
Definition: sqltypes.h:261
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_nullable_logical_type_info()

SQLTypeInfo get_nullable_logical_type_info ( const SQLTypeInfo type_info)
inline

Definition at line 840 of file sqltypes.h.

References get_logical_type_info(), and get_nullable_type_info().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::get_logical_type_for_expr(), and RelAlgTranslator::translateArrayFunction().

840  {
841  SQLTypeInfo nullable_type_info = get_logical_type_info(type_info);
842  return get_nullable_type_info(nullable_type_info);
843 }
SQLTypeInfo get_logical_type_info(const SQLTypeInfo &type_info)
Definition: sqltypes.h:819
SQLTypeInfo get_nullable_type_info(const SQLTypeInfo &type_info)
Definition: sqltypes.h:834
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_nullable_type_info()

SQLTypeInfo get_nullable_type_info ( const SQLTypeInfo type_info)
inline

Definition at line 834 of file sqltypes.h.

References SQLTypeInfo::set_notnull().

Referenced by CodeGenerator::createInValuesBitmap(), Analyzer::Constant::do_cast(), and get_nullable_logical_type_info().

834  {
835  SQLTypeInfo nullable_type_info = type_info;
836  nullable_type_info.set_notnull(false);
837  return nullable_type_info;
838 }
void set_notnull(bool n)
Definition: sqltypes.h:356
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ inline_int_null_array_value()

template<class T >
constexpr int64_t inline_int_null_array_value ( )
inline

Definition at line 852 of file sqltypes.h.

852  {
853  return std::is_signed<T>::value ? std::numeric_limits<T>::min() + 1
854  : std::numeric_limits<T>::max() - 1;
855  // TODO: null_array values in signed types would step on max valid value
856  // in fixlen unsigned arrays, the max valid value may need to be lowered.
857 }

◆ inline_int_null_value()

template<class T >
constexpr int64_t inline_int_null_value ( )
inline

Definition at line 846 of file sqltypes.h.

846  {
847  return std::is_signed<T>::value ? std::numeric_limits<T>::min()
848  : std::numeric_limits<T>::max();
849 }

◆ is_cuda_compiler()

DEVICE constexpr bool is_cuda_compiler ( )
inline

Definition at line 122 of file sqltypes.h.

122  {
123 #ifdef __CUDACC__
124  return true;
125 #else
126  return false;
127 #endif
128 }

◆ is_datetime()

constexpr auto is_datetime ( SQLTypes  type)

Definition at line 202 of file sqltypes.h.

References kDATE, kTIME, and kTIMESTAMP.

Referenced by SQLTypeInfo::is_time(), DateTimeStringValidate< SQL_TYPE >::operator()(), foreign_storage::anonymous_namespace{LazyParquetImporter.cpp}::read_parquet_metadata_into_import_buffer(), and RexLiteral::RexLiteral().

202  {
203  return type == kTIME || type == kTIMESTAMP || type == kDATE;
204 }
Definition: sqltypes.h:51
Definition: sqltypes.h:55
+ Here is the caller graph for this function:

◆ max_valid_int_value()

template<class T >
constexpr int64_t max_valid_int_value ( )
inline

Definition at line 860 of file sqltypes.h.

860  {
861  return std::is_signed<T>::value ? std::numeric_limits<T>::max()
862  : std::numeric_limits<T>::max() - 1;
863 }

◆ StringToDatum()

Datum StringToDatum ( std::string_view  s,
SQLTypeInfo ti 
)

Definition at line 124 of file Datum.cpp.

References Datum::bigintval, Datum::boolval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_dimension(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Datum::intval, kARRAY, kBIGINT, kBOOLEAN, kCOLUMN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, parse_numeric(), Datum::smallintval, Datum::tinyintval, and to_upper().

Referenced by import_export::TypedImportBuffer::add_value(), Parser::FixedPtLiteral::analyze(), Analyzer::Constant::cast_from_string(), SQLTypeInfo::get_storage_size(), anonymous_namespace{ArrowImporter.h}::ArrowValue< std::string >::operator const bool(), anonymous_namespace{ArrowImporter.h}::ArrowValue< std::string >::operator const DATA_TYPE(), populate_TColumn(), and import_export::StringToArray().

124  {
125  Datum d;
126  try {
127  switch (ti.get_type()) {
128  case kARRAY:
129  case kCOLUMN:
130  break;
131  case kBOOLEAN:
132  if (s == "t" || s == "T" || s == "1" || to_upper(std::string(s)) == "TRUE") {
133  d.boolval = true;
134  } else if (s == "f" || s == "F" || s == "0" ||
135  to_upper(std::string(s)) == "FALSE") {
136  d.boolval = false;
137  } else {
138  throw std::runtime_error("Invalid string for boolean " + std::string(s));
139  }
140  break;
141  case kNUMERIC:
142  case kDECIMAL:
143  d.bigintval = parse_numeric(s, ti);
144  break;
145  case kBIGINT:
146  d.bigintval = std::stoll(std::string(s));
147  break;
148  case kINT:
149  d.intval = std::stoi(std::string(s));
150  break;
151  case kSMALLINT:
152  d.smallintval = std::stoi(std::string(s));
153  break;
154  case kTINYINT:
155  d.tinyintval = std::stoi(std::string(s));
156  break;
157  case kFLOAT:
158  d.floatval = std::stof(std::string(s));
159  break;
160  case kDOUBLE:
161  d.doubleval = std::stod(std::string(s));
162  break;
163  case kTIME:
164  d.bigintval = DateTimeStringValidate<kTIME>()(std::string(s), ti.get_dimension());
165  break;
166  case kTIMESTAMP:
167  d.bigintval =
168  DateTimeStringValidate<kTIMESTAMP>()(std::string(s), ti.get_dimension());
169  break;
170  case kDATE:
171  d.bigintval = DateTimeStringValidate<kDATE>()(std::string(s), ti.get_dimension());
172  break;
173  case kPOINT:
174  case kLINESTRING:
175  case kPOLYGON:
176  case kMULTIPOLYGON:
177  throw std::runtime_error("Internal error: geometry type in StringToDatum.");
178  default:
179  throw std::runtime_error("Internal error: invalid type in StringToDatum.");
180  }
181  } catch (const std::invalid_argument&) {
182  throw std::runtime_error("Invalid conversion from string to " + ti.get_type_name());
183  } catch (const std::out_of_range&) {
184  throw std::runtime_error("Got out of range error during conversion from string to " +
185  ti.get_type_name());
186  }
187  return d;
188 }
int8_t tinyintval
Definition: sqltypes.h:135
Definition: sqltypes.h:51
int64_t parse_numeric(const std::string_view s, SQLTypeInfo &ti)
Definition: Datum.cpp:71
bool boolval
Definition: sqltypes.h:134
int32_t intval
Definition: sqltypes.h:137
float floatval
Definition: sqltypes.h:139
int64_t bigintval
Definition: sqltypes.h:138
int16_t smallintval
Definition: sqltypes.h:136
std::string to_upper(const std::string &str)
Definition: sqltypes.h:55
std::string get_type_name() const
Definition: sqltypes.h:362
HOST DEVICE int get_dimension() const
Definition: sqltypes.h:261
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
Definition: sqltypes.h:47
double doubleval
Definition: sqltypes.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function: