sqltypes.h File Reference

Constants for Builtin SQL Types supported by HEAVY.AI. More...

#include "toString.h"
#include "../Logger/Logger.h"
#include "../QueryEngine/Utils/FlatBuffer.h"
#include "Datum.h"
#include "funcannotations.h"
#include "sqltypes_lite.h"
#include <cassert>
#include <ctime>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
#include "Shared/DbObjectKeys.h"
#include "InlineNullValues.h"
#include <string_view>
#include "../QueryEngine/DateAdd.h"
#include "../QueryEngine/DateTruncate.h"
#include "../QueryEngine/ExtractFromTime.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	DoNothingDeleter
struct	FreeDeleter
struct	HostArrayDatum
struct	DeviceArrayDatum
union	DataBlockPtr
class	SQLTypeInfo
union	null_value_t
struct	SqlLiteralArg

Namespaces
	sql_constants

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)
#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	IS_GEO_LINE(T)   (((T) == kLINESTRING) || ((T) == kMULTILINESTRING))
#define	IS_GEO_MULTI(T)   (((T) == kMULTIPOLYGON) || ((T) == kMULTILINESTRING) || ((T) == kMULTIPOINT))
#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, kCOLUMN_LIST = 29, kMULTILINESTRING = 30, kMULTIPOINT = 31,   kSQLTYPE_LAST = 32 }
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_ARRAY = 8, kENCODING_ARRAY_DICT = 9, kENCODING_LAST = 10 }

Functions
std::string	toString (const SQLTypes &type)
std::ostream &	operator<< (std::ostream &os, SQLTypes const sql_type)
DEVICE constexpr bool	is_cuda_compiler ()
std::ostream &	operator<< (std::ostream &os, EncodingType const type)
std::string	toString (const EncodingType &type)
constexpr auto	is_datetime (SQLTypes type)
SQLTypes	decimal_to_int_type (const SQLTypeInfo &)
SQLTypes	string_dict_to_int_type (const SQLTypeInfo &)
Datum	NullDatum (const SQLTypeInfo &ti)
bool	IsNullDatum (const Datum d, const SQLTypeInfo &ti)
Datum	StringToDatum (const std::string_view s, SQLTypeInfo &ti)
std::string	DatumToString (const Datum d, const SQLTypeInfo &ti)
int64_t	extract_int_type_from_datum (const Datum datum, const SQLTypeInfo &ti)
double	extract_fp_type_from_datum (const Datum datum, 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)
std::ostream &	operator<< (std::ostream &os, const SQLTypeInfo &type_info)
SQLTypes	get_int_type_by_size (size_t const nbytes)
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)
int8_t *	append_datum (int8_t *buf, const Datum &d, const SQLTypeInfo &ti)
auto	generate_column_type (const SQLTypeInfo &elem_ti)
auto	generate_column_list_type (const SQLTypeInfo &elem_ti)
DEVICE void	VarlenArray_get_nth (int8_t *buf, int n, ArrayDatum *result, bool *is_end)
DEVICE void	VarlenArray_get_nth (int8_t *buf, int n, bool uncompress, VarlenDatum *result, bool *is_end)
void	getFlatBufferNDimsAndSizes (const int64_t items_count, const int64_t max_nof_values, const SQLTypeInfo &ti, size_t &ndims, int64_t &max_nof_sizes)
int64_t	getFlatBufferSize (int64_t items_count, int64_t max_nof_values, const SQLTypeInfo &ti)
null_value_t	get_null_value (const SQLTypeInfo &ti)
void	initializeFlatBuffer (FlatBufferManager &m, int64_t items_count, int64_t max_nof_values, const SQLTypeInfo &ti)
bool	geo_promoted_type_match (const SQLTypes a, const SQLTypes b)

Variables
static constexpr int32_t	sql_constants::kMaxNumericPrecision
static constexpr int32_t	sql_constants::kMaxRepresentableNumericPrecision

Detailed Description

Constants for Builtin SQL Types supported by HEAVY.AI.

Definition in file sqltypes.h.

Macro Definition Documentation

#define IS_DECIMAL

(

T

)

((T) == kNUMERIC || (T) == kDECIMAL)

Definition at line 314 of file sqltypes.h.

#define IS_GEO

(

T

)

Value:

(((T) == kPOINT) || ((T) == kLINESTRING) || ((T) == kMULTILINESTRING) || \
   ((T) == kMULTIPOINT) || ((T) == kPOLYGON) || ((T) == kMULTIPOLYGON))

Definition at line 310 of file sqltypes.h.

Referenced by spatial_type::Distance::codegenLoads(), RelAlgExecutor::createTableFunctionWorkUnit(), Catalog_Namespace::Catalog::expandGeoColumn(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_type_name(), Executor::getColLazyFetchInfo(), anonymous_namespace{DdlCommandExecutor.cpp}::JsonColumnSqlType::getParam1(), anonymous_namespace{DdlCommandExecutor.cpp}::JsonColumnSqlType::getParam2(), EmbeddedDatabase::DBEngineImpl::getTableDetails(), import_export::import_thread_delimited(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_varlen(), ResultSet::isGeoColOnGpu(), DBHandler::populateThriftColumnType(), foreign_storage::TextFileBufferParser::processGeoColumn(), foreign_storage::TextFileBufferParser::processInvalidGeoColumn(), ThriftSerializers::target_meta_info_to_thrift(), thrift_to_name(), SQLTypeInfo::transforms(), RelAlgTranslator::translateGeoColumn(), RelAlgTranslator::translateGeoFunctionArg(), RelAlgTranslator::translateUnaryGeoFunction(), type_info_from_thrift(), ThriftSerializers::type_info_to_thrift(), ddl_utils::validate_and_set_type(), and anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor::visitInput().

#define IS_GEO_LINE

(

T

)

(((T) == kLINESTRING) || ((T) == kMULTILINESTRING))

Definition at line 316 of file sqltypes.h.

#define IS_GEO_MULTI

(

T

)

(((T) == kMULTIPOLYGON) || ((T) == kMULTILINESTRING) || ((T) == kMULTIPOINT))

Definition at line 317 of file sqltypes.h.

Referenced by spatial_type::NumGeometries::codegenLoads().

#define IS_GEO_POLY

(

T

)

(((T) == kPOLYGON) || ((T) == kMULTIPOLYGON))

Definition at line 315 of file sqltypes.h.

Referenced by CodeGenerator::codegenBoundingBoxIntersect(), and RelAlgTranslator::translateUnaryGeoFunction().

#define IS_INTEGER

(

T

)

(((T) == kINT) || ((T) == kSMALLINT) || ((T) == kBIGINT) || ((T) == kTINYINT))

Definition at line 304 of file sqltypes.h.

Referenced by Analyzer::StringOper::check_operand_types(), anonymous_namespace{ArrowResultSetConverter.cpp}::get_physical_type(), getArrowImportType(), StringOps_Namespace::StringOpInfo::getIntLiteral(), StringOps_Namespace::StringOpInfo::intLiteralArgAtIdxExists(), SQLTypeInfo::is_integer(), StringOps_Namespace::StringOpInfo::isLiteralArgNull(), StringOps_Namespace::operator<<(), import_export::parse_add_metadata_columns(), and ddl_utils::validate_and_set_fixed_encoding().

#define IS_INTERVAL

(

T

)

((T) == kINTERVAL_DAY_TIME || (T) == kINTERVAL_YEAR_MONTH)

Definition at line 313 of file sqltypes.h.

Referenced by SQLTypeInfo::is_timeinterval().

#define IS_NUMBER

(

T

)

Value:

(((T) == kINT) || ((T) == kSMALLINT) || ((T) == kDOUBLE) || ((T) == kFLOAT) || \
   ((T) == kBIGINT) || ((T) == kNUMERIC) || ((T) == kDECIMAL) || ((T) == kTINYINT))

Definition at line 306 of file sqltypes.h.

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

#define IS_STRING

(

T

)

(((T) == kTEXT) || ((T) == kVARCHAR) || ((T) == kCHAR))

Definition at line 309 of file sqltypes.h.

Referenced by import_export::TypedImportBuffer::add_value(), import_export::TypedImportBuffer::add_values(), import_export::TypedImportBuffer::addDefaultValues(), import_export::TypedImportBuffer::clear(), foreign_storage::TextFileBufferParser::convertImportBuffersToDataBlocks(), Encoder::Create(), import_export::fill_missing_columns(), import_export::Loader::fillShardRow(), import_export::Detector::find_best_encodings(), import_export::TypedImportBuffer::get_data_block_pointers(), import_export::Loader::getStringDict(), StringOps_Namespace::StringOpInfo::getStringLiteral(), foreign_storage::anonymous_namespace{InternalSystemDataWrapper.cpp}::initialize_import_buffers(), SQLTypeInfo::is_string(), SQLTypeInfo::is_string_array(), SQLTypeInfo::is_subtype_dict_encoded_string(), SQLTypeInfo::is_varlen(), StringOps_Namespace::StringOpInfo::isLiteralArgNull(), anonymous_namespace{EquiJoinCondition.cpp}::make_composite_equals_impl(), StringOps_Namespace::operator<<(), foreign_storage::ParseBufferRequest::ParseBufferRequest(), import_export::TypedImportBuffer::pop_value(), StringOps_Namespace::StringOpInfo::stringLiteralArgAtIdxExists(), RelAlgTranslator::translateGeoFunctionArg(), import_export::TypedImportBuffer::TypedImportBuffer(), and import_export::TypedImportBuffer::~TypedImportBuffer().

#define REGULAR_DICT

(

TRANSIENTID

)

(-(TRANSIENTID))

Definition at line 323 of file sqltypes.h.

Referenced by RowSetMemoryOwner::getOrAddStringDictProxy().

#define TRANSIENT_DICT

(

ID

)

(-(ID))

Definition at line 322 of file sqltypes.h.

Referenced by Analyzer::CaseExpr::add_cast(), Parser::common_string_type(), Analyzer::anonymous_namespace{Analyzer.cpp}::has_same_dict(), SQLTypeInfo::operator!=(), and SQLTypeInfo::operator==().

Typedef Documentation

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

Definition at line 229 of file sqltypes.h.

using ArrayOffsetT = int32_t

Definition at line 1496 of file sqltypes.h.

using StringOffsetT = int32_t

Definition at line 1495 of file sqltypes.h.

Enumeration Type Documentation

enum EncodingType

Enumerator
kENCODING_NONE
kENCODING_FIXED
kENCODING_RL
kENCODING_DIFF
kENCODING_DICT
kENCODING_SPARSE
kENCODING_GEOINT
kENCODING_DATE_IN_DAYS
kENCODING_ARRAY
kENCODING_ARRAY_DICT
kENCODING_LAST

Definition at line 240 of file sqltypes.h.

                  {
  kENCODING_NONE = 0,          // no encoding
  kENCODING_FIXED = 1,         // Fixed-bit encoding
  kENCODING_RL = 2,            // Run Length encoding
  kENCODING_DIFF = 3,          // Differential encoding
  kENCODING_DICT = 4,          // Dictionary encoding
  kENCODING_SPARSE = 5,        // Null encoding for sparse columns
  kENCODING_GEOINT = 6,        // Encoding coordinates as intergers
  kENCODING_DATE_IN_DAYS = 7,  // Date encoding in days
  kENCODING_ARRAY = 8,         // Array encoding for columns of arrays
  kENCODING_ARRAY_DICT = 9,    // Array encoding for columns of text encoding dict arrays
  kENCODING_LAST = 10
};

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
kCOLUMN_LIST
kMULTILINESTRING
kMULTIPOINT
kSQLTYPE_LAST

Definition at line 65 of file sqltypes.h.

              {
  kNULLT = 0,  // type for null values
  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,  // Placeholder Type for ANY
  kVOID = 26,
  kCURSOR = 27,
  kCOLUMN = 28,
  kCOLUMN_LIST = 29,
  kMULTILINESTRING = 30,
  kMULTIPOINT = 31,
  kSQLTYPE_LAST = 32
};

Function Documentation

int8_t* append_datum	(	int8_t *	buf,
		const Datum &	d,
		const SQLTypeInfo &	ti
	)

Definition at line 580 of file Datum.cpp.

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

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

                                                                         {
  SQLTypes type;
  if (ti.is_dict_encoded_string()) {
    type = string_dict_to_int_type(ti);
  } else {
    type = ti.get_type();
  }
  switch (type) {
    case kBOOLEAN:
      *(int8_t*)buf = d.boolval;
      return buf + sizeof(int8_t);
    case kNUMERIC:
    case kDECIMAL:
    case kBIGINT:
      *(int64_t*)buf = d.bigintval;
      return buf + sizeof(int64_t);
    case kINT:
      *(int32_t*)buf = d.intval;
      return buf + sizeof(int32_t);
    case kSMALLINT:
      *(int16_t*)buf = d.smallintval;
      return buf + sizeof(int16_t);
    case kTINYINT:
      *(int8_t*)buf = d.tinyintval;
      return buf + sizeof(int8_t);
    case kFLOAT:
      *(float*)buf = d.floatval;
      return buf + sizeof(float);
    case kDOUBLE:
      *(double*)buf = d.doubleval;
      return buf + sizeof(double);
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      *reinterpret_cast<int64_t*>(buf) = d.bigintval;
      return buf + sizeof(int64_t);
    default:
      UNREACHABLE() << "Unexpected type: " << type;
      return nullptr;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 624 of file Datum.cpp.

References anonymous_namespace{Datum.cpp}::convert_decimal_value_to_scale_internal(), and SQLTypeInfo::get_scale().

Referenced by import_export::TypedImportBuffer::addDefaultValues(), Analyzer::Constant::cast_number(), anonymous_namespace{ArrowImporter.h}::ArrowValue< arrow::Decimal128 >::operator DATA_TYPE(), parse_numeric(), anonymous_namespace{TypedDataAccessors.h}::put_scalar(), and ddl_utils::anonymous_namespace{DdlUtils.cpp}::validate_literal().

                                                                         {
  int const dscale = new_type_info.get_scale() - type_info.get_scale();
  return convert_decimal_value_to_scale_internal(decimal_value, dscale);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 408 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, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::stringval, and Datum::tinyintval.

Referenced by IsNullDatum(), ChunkMetadata::operator==(), FixedLengthArrayNoneEncoder::resetChunkStats(), and ArrayNoneEncoder::resetChunkStats().

                                                                     {
  switch (ti.get_type()) {
    case kBOOLEAN:
      return a.boolval == b.boolval;
    case kBIGINT:
    case kNUMERIC:
    case kDECIMAL:
      return a.bigintval == b.bigintval;
    case kINT:
      return a.intval == b.intval;
    case kSMALLINT:
      return a.smallintval == b.smallintval;
    case kTINYINT:
      return a.tinyintval == b.tinyintval;
    case kFLOAT:
      return a.floatval == b.floatval;
    case kDOUBLE:
      return a.doubleval == b.doubleval;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH:
      return a.bigintval == b.bigintval;
    case kTEXT:
    case kVARCHAR:
    case kCHAR:
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      if (ti.get_compression() == kENCODING_DICT) {
        return a.intval == b.intval;
      }
      if (a.stringval == nullptr && b.stringval == nullptr) {
        return true;
      }
      if (a.stringval == nullptr || b.stringval == nullptr) {
        return false;
      }
      return *a.stringval == *b.stringval;
    default:
      return false;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 460 of file Datum.cpp.

References Datum::bigintval, Datum::boolval, CHECK_EQ, CHECK_LE, CHECK_LT, 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, to_string(), and SQLTypeInfo::to_string().

Referenced by anonymous_namespace{TableFunctionExecutionContext.cpp}::append_literal_buffer(), Analyzer::Constant::cast_to_string(), foreign_storage::datetime_to_string(), foreign_storage::TypedParquetInPlaceEncoder< V, V >::integralTypeToString(), anonymous_namespace{ArrowImporter.h}::ArrowValue< int64_t >::operator DATA_TYPE(), operator<<(), import_export::anonymous_namespace{QueryExporterCSV.cpp}::target_value_to_string(), Analyzer::Constant::toString(), Timestamp::toString(), Fragmenter_Namespace::InsertOrderFragmenter::updateChunkStats(), and ScalarExprToSql::visitConstant().

                                                        {
  constexpr size_t buf_size = 64;
  char buf[buf_size];  // Hold "2000-03-01 12:34:56.123456789" and large years.
  switch (ti.get_type()) {
    case kBOOLEAN:
      if (d.boolval) {
        return "t";
      }
      return "f";
    case kNUMERIC:
    case kDECIMAL: {
      double v = (double)d.bigintval / pow(10, ti.get_scale());
      int size = snprintf(buf, buf_size, "%*.*f", ti.get_dimension(), ti.get_scale(), v);
      CHECK_LE(0, size) << v << ' ' << ti.to_string();
      CHECK_LT(size_t(size), buf_size) << v << ' ' << ti.to_string();
      return buf;
    }
    case kINT:
      return std::to_string(d.intval);
    case kSMALLINT:
      return std::to_string(d.smallintval);
    case kTINYINT:
      return std::to_string(d.tinyintval);
    case kBIGINT:
      return std::to_string(d.bigintval);
    case kFLOAT:
      return std::to_string(d.floatval);
    case kDOUBLE:
      return std::to_string(d.doubleval);
    case kTIME: {
      size_t const len = shared::formatHMS(buf, buf_size, d.bigintval);
      CHECK_EQ(8u, len);  // 8 == strlen("HH:MM:SS")
      return buf;
    }
    case kTIMESTAMP: {
      unsigned const dim = ti.get_dimension();  // assumes dim <= 9
      size_t const len = shared::formatDateTime(buf, buf_size, d.bigintval, dim);
      CHECK_LE(19u + bool(dim) + dim, len);  // 19 = strlen("YYYY-MM-DD HH:MM:SS")
      return buf;
    }
    case kDATE: {
      size_t const len = shared::formatDate(buf, buf_size, d.bigintval);
      CHECK_LE(10u, len);  // 10 == strlen("YYYY-MM-DD")
      return buf;
    }
    case kINTERVAL_DAY_TIME:
      return std::to_string(d.bigintval) + " ms (day-time interval)";
    case kINTERVAL_YEAR_MONTH:
      return std::to_string(d.bigintval) + " month(s) (year-month interval)";
    case kTEXT:
    case kVARCHAR:
    case kCHAR:
      if (d.stringval == nullptr) {
        return "NULL";
      }
      return *d.stringval;
    default:
      throw std::runtime_error("Internal error: invalid type " + ti.get_type_name() +
                               " in DatumToString.");
  }
  return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypes decimal_to_int_type

(

const SQLTypeInfo &

)

Definition at line 561 of file Datum.cpp.

References get_int_type_by_size(), and SQLTypeInfo::get_size().

Referenced by import_export::TypedImportBuffer::add_value(), WindowFunctionContext::buildAggregationTreeForPartition(), CodeGenerator::codegen(), CodeGenerator::codegenIntConst(), anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division(), extract_int_type_from_datum(), import_export::Loader::fillShardRow(), anonymous_namespace{ColumnIR.cpp}::get_col_decoder(), import_export::anonymous_namespace{Importer.cpp}::get_type_for_datum(), anonymous_namespace{Datum.cpp}::get_type_for_datum(), CgenState::getOrAddLiteral(), ChunkMetadata::isPlaceholder(), ResultSet::makeTargetValue(), import_export::TypedImportBuffer::pop_value(), import_export::TDatumToDatum(), anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitBinOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitUOper().

                                                    {
  return get_int_type_by_size(ti.get_size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

double extract_fp_type_from_datum	(	const Datum	datum,
		const SQLTypeInfo &	ti
	)

Definition at line 549 of file Datum.cpp.

References Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), kDOUBLE, kFLOAT, and run_benchmark_import::type.

Referenced by extract_max_stat_fp_type(), and extract_min_stat_fp_type().

                                                                            {
  const auto type = ti.get_type();
  switch (type) {
    case kFLOAT:
      return datum.floatval;
    case kDOUBLE:
      return datum.doubleval;
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t extract_int_type_from_datum	(	const Datum	datum,
		const SQLTypeInfo &	ti
	)

Definition at line 523 of file Datum.cpp.

References Datum::bigintval, CHECK_EQ, decimal_to_int_type(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_type(), Datum::intval, SQLTypeInfo::is_decimal(), kBIGINT, kBOOLEAN, kCHAR, kDATE, kENCODING_DICT, kINT, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::tinyintval, and run_benchmark_import::type.

Referenced by extract_max_stat_int_type(), extract_min_stat_int_type(), StringOps_Namespace::StringOpInfo::getIntLiteral(), ChunkMetadata::isPlaceholder(), and StringOps_Namespace::operator<<().

                                                                              {
  const auto type = ti.is_decimal() ? decimal_to_int_type(ti) : ti.get_type();
  switch (type) {
    case kBOOLEAN:
      return datum.tinyintval;
    case kTINYINT:
      return datum.tinyintval;
    case kSMALLINT:
      return datum.smallintval;
    case kCHAR:
    case kVARCHAR:
    case kTEXT:
      CHECK_EQ(kENCODING_DICT, ti.get_compression());
    case kINT:
      return datum.intval;
    case kBIGINT:
      return datum.bigintval;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return datum.bigintval;
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

auto generate_column_list_type ( const SQLTypeInfo &  elem_ti )

inline

Definition at line 1701 of file sqltypes.h.

References generate_column_type(), kCOLUMN_LIST, kNULLT, and kTIMESTAMP.

Referenced by bind_function().

                                                                  {
  auto type_info = generate_column_type(elem_ti);
  if (type_info.get_subtype() != kNULLT) {
    type_info.set_type(kCOLUMN_LIST);
  }
  if (type_info.get_subtype() == kTIMESTAMP) {
    // ColumnList<Timestamp> is not supported, see QE-472
    type_info.set_subtype(kNULLT);
  }
  return type_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

auto generate_column_type ( const SQLTypeInfo &  elem_ti )

inline

Definition at line 1629 of file sqltypes.h.

References SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), SQLTypeInfo::getStringDictKey(), IS_NUMBER, kARRAY, kBIGINT, kBOOLEAN, kCOLUMN, kDOUBLE, kENCODING_ARRAY, kENCODING_ARRAY_DICT, kENCODING_DICT, kENCODING_GEOINT, kENCODING_NONE, kFLOAT, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIMESTAMP, kTINYINT, kVARCHAR, and SQLTypeInfo::set_subtype().

Referenced by bind_function(), and generate_column_list_type().

                                                             {
  SQLTypes elem_type = elem_ti.get_type();
  if (elem_type == kCOLUMN) {
    if (elem_ti.get_subtype() == kVARCHAR) {
      auto new_elem_ti = elem_ti;
      new_elem_ti.set_subtype(kTEXT);
      return new_elem_ti;
    }
    return elem_ti;
  }
  auto c = elem_ti.get_compression();
  auto d = elem_ti.get_dimension();
  auto s = elem_ti.get_scale();
  auto p = elem_ti.get_comp_param();
  switch (elem_type) {
    case kBOOLEAN:
    case kTINYINT:
    case kSMALLINT:
    case kINT:
    case kBIGINT:
    case kFLOAT:
    case kDOUBLE:
      if (c == kENCODING_NONE && p == 0) {
        break;  // here and below `break` means supported element type
                // for extension functions
      }
    case kPOINT:
    case kLINESTRING:
    case kPOLYGON:
    case kMULTIPOINT:
    case kMULTILINESTRING:
    case kMULTIPOLYGON:
      if (c == kENCODING_NONE && p == 0) {
        break;
      }
      if (c == kENCODING_GEOINT && p == 32) {
        break;
      }
    case kTEXT:
    case kVARCHAR:
      elem_type = kTEXT;
      if (c == kENCODING_DICT) {
        break;
      }
    case kTIMESTAMP:
      if (c == kENCODING_NONE && p == 0 && (d == 9 || d == 6 || d == 0)) {
        break;
      }
    case kARRAY:
      elem_type = elem_ti.get_subtype();
      if (IS_NUMBER(elem_type) || elem_type == kBOOLEAN || elem_type == kTEXT) {
        if (c == kENCODING_NONE && p == 0) {
          c = kENCODING_ARRAY;
          break;
        } else if (c == kENCODING_DICT) {
          c = kENCODING_ARRAY_DICT;
          break;
        }
      }
    default:
      elem_type = kNULLT;  // indicates unsupported element type that
                           // the caller needs to handle accordingly
  }
  auto ti = SQLTypeInfo(kCOLUMN, c, p, elem_type);
  ti.set_dimension(d);
  if (c == kENCODING_DICT) {
    ti.setStringDictKey(elem_ti.getStringDictKey());
  }
  ti.set_scale(s);
  return ti;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool geo_promoted_type_match ( const SQLTypes  a, const SQLTypes  b  )

inline

Definition at line 2031 of file sqltypes.h.

References kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, and kPOLYGON.

Referenced by Parser::InsertValuesStmt::analyze(), Geospatial::GeoTypesFactory::getGeoColumns(), import_export::import_thread_delimited(), import_export::import_thread_shapefile(), foreign_storage::TextFileBufferParser::processGeoColumn(), and foreign_storage::GeospatialEncoder::processGeoElement().

                                                                        {
  return (a == b) || (a == kPOINT && b == kMULTIPOINT) ||
         (a == kLINESTRING && b == kMULTILINESTRING) ||
         (a == kPOLYGON && b == kMULTIPOLYGON);
}

Here is the caller graph for this function:

SQLTypes get_int_type_by_size ( size_t const  nbytes )

inline

Definition at line 1454 of file sqltypes.h.

References kBIGINT, kINT, kSMALLINT, kTINYINT, and UNREACHABLE.

Referenced by WindowFunctionContext::buildAggregationTreeForPartition(), anonymous_namespace{RelAlgExecutor.cpp}::anonymous_namespace{RelAlgExecutor.cpp}::conditionally_change_arg_to_int_type(), and decimal_to_int_type().

                                                          {
  switch (nbytes) {
    case 1:
      return kTINYINT;
    case 2:
      return kSMALLINT;
    case 4:
      return kINT;
    case 8:
      return kBIGINT;
    default:
#if !(defined(__CUDACC__) || defined(NO_BOOST))
      UNREACHABLE() << "Invalid number of bytes=" << nbytes;
#endif
      return {};
  }
}

Here is the caller graph for this function:

SQLTypeInfo get_logical_type_info ( const SQLTypeInfo &  type_info )

inline

Definition at line 1472 of file sqltypes.h.

References SQLTypeInfo::get_compression(), SQLTypeInfo::get_type(), kARRAY, kENCODING_DATE_IN_DAYS, kENCODING_FIXED, kENCODING_NONE, and SQLTypeInfo::set_compression().

Referenced by anonymous_namespace{ColumnFetcher.cpp}::columnarize_result(), 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(), target_info::get_target_info_impl(), TableOptimizer::getDeletedColumnStats(), PerfectJoinHashTable::getHashJoinArgs(), getLeafColumnRange(), Parser::CaseExpr::normalize(), TableOptimizer::recomputeColumnMetadata(), Fragmenter_Namespace::InsertOrderFragmenter::updateChunkStats(), and Fragmenter_Namespace::InsertOrderFragmenter::updateColumns().

                                                                       {
  EncodingType encoding = type_info.get_compression();
  if (encoding == kENCODING_DATE_IN_DAYS ||
      (encoding == kENCODING_FIXED && type_info.get_type() != kARRAY)) {
    encoding = kENCODING_NONE;
  }
  auto type_info_copy = type_info;
  type_info_copy.set_compression(encoding);
  type_info_copy.setStorageSize();
  return type_info_copy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

null_value_t get_null_value ( const SQLTypeInfo &  ti )

inline

Definition at line 1893 of file sqltypes.h.

References CHECK_EQ, SQLTypeInfo::get_compression(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), kARRAY, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kENCODING_DICT, kENCODING_GEOINT, kENCODING_NONE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, NULL_ARRAY_BIGINT, NULL_ARRAY_BOOLEAN, NULL_ARRAY_COMPRESSED_32, NULL_ARRAY_DOUBLE, NULL_ARRAY_FLOAT, NULL_ARRAY_INT, NULL_ARRAY_SMALLINT, NULL_ARRAY_TINYINT, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, NULL_TINYINT, and UNREACHABLE.

                                                          {
  null_value_t null_value{};
  switch (ti.get_type()) {
    case kBOOLEAN:
      null_value.i8 = NULL_BOOLEAN;
      break;
    case kTINYINT:
      null_value.i8 = NULL_TINYINT;
      break;
    case kSMALLINT:
      null_value.i16 = NULL_SMALLINT;
      break;
    case kINT:
      null_value.i32 = NULL_INT;
      break;
    case kBIGINT:
      null_value.i64 = NULL_BIGINT;
      break;
    case kFLOAT:
      null_value.f32 = NULL_FLOAT;
      break;
    case kDOUBLE:
      null_value.f64 = NULL_DOUBLE;
      break;
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      if (ti.get_compression() == kENCODING_GEOINT) {
        null_value.geoint[0] = null_value.geoint[1] = NULL_ARRAY_COMPRESSED_32;
      } else if (ti.get_compression() == kENCODING_NONE) {
        null_value.geodouble[0] = null_value.geodouble[1] = NULL_ARRAY_DOUBLE;
      } else {
        UNREACHABLE();
      }
      break;
    case kARRAY:
      switch (ti.get_subtype()) {
        case kBOOLEAN:
          null_value.i8 = NULL_ARRAY_BOOLEAN;
          break;
        case kTINYINT:
          null_value.i8 = NULL_ARRAY_TINYINT;
          break;
        case kSMALLINT:
          null_value.i16 = NULL_ARRAY_SMALLINT;
          break;
        case kINT:
          null_value.i32 = NULL_ARRAY_INT;
          break;
        case kTIMESTAMP:
        case kTIME:
        case kDATE:
        case kINTERVAL_DAY_TIME:
        case kINTERVAL_YEAR_MONTH:
        case kDECIMAL:
        case kNUMERIC:
        case kBIGINT:
          null_value.i64 = NULL_ARRAY_BIGINT;
          break;
        case kFLOAT:
          null_value.f32 = NULL_ARRAY_FLOAT;
          break;
        case kDOUBLE:
          null_value.f64 = NULL_ARRAY_FLOAT;
          break;
        case kTEXT:
          if (ti.get_compression() == kENCODING_DICT) {
            CHECK_EQ(ti.get_logical_size(), 4);
            null_value.i32 = NULL_ARRAY_COMPRESSED_32;
          } else if (ti.get_compression() == kENCODING_NONE) {
            null_value.i8 = NULL_ARRAY_TINYINT;
          } else {
            UNREACHABLE();
          }
          break;
        default:
          UNREACHABLE();
          break;
      }
      break;
    case kTEXT:
      if (ti.get_compression() == kENCODING_DICT) {
        CHECK_EQ(ti.get_logical_size(), 4);
        null_value.i32 = NULL_INT;
      } else if (ti.get_compression() == kENCODING_NONE) {
        null_value.i32 = NULL_TINYINT;
      } else {
        UNREACHABLE();
      }
      break;
    default:
      UNREACHABLE();
      break;
  }
  return null_value;
}

Here is the call graph for this function:

SQLTypeInfo get_nullable_logical_type_info ( const SQLTypeInfo &  type_info )

inline

Definition at line 1490 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().

                                                                                {
  SQLTypeInfo nullable_type_info = get_logical_type_info(type_info);
  return get_nullable_type_info(nullable_type_info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypeInfo get_nullable_type_info ( const SQLTypeInfo &  type_info )

inline

Definition at line 1484 of file sqltypes.h.

References SQLTypeInfo::set_notnull().

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

                                                                        {
  SQLTypeInfo nullable_type_info = type_info;
  nullable_type_info.set_notnull(false);
  return nullable_type_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void getFlatBufferNDimsAndSizes ( const int64_t  items_count, const int64_t  max_nof_values, const SQLTypeInfo &  ti, size_t &  ndims, int64_t &  max_nof_sizes  )

inline

Definition at line 1789 of file sqltypes.h.

References SQLTypeInfo::get_compression(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), kARRAY, kENCODING_DICT, kENCODING_NONE, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, kTEXT, and UNREACHABLE.

Referenced by getFlatBufferSize(), and initializeFlatBuffer().

                                                               {
  ndims = 0;
  max_nof_sizes = 0;
  switch (ti.get_type()) {
    case kPOINT:
      ndims = 0;
      break;
    case kARRAY:
      if (ti.get_subtype() == kTEXT && ti.get_compression() == kENCODING_NONE) {
        ndims = 2;
        max_nof_sizes = items_count + 2 * max_nof_values / 3;
      } else {
        ndims = 1;
        max_nof_sizes = items_count + max_nof_values / 3;
      }
      break;
    case kLINESTRING:
    case kMULTIPOINT:
      ndims = 1;
      max_nof_sizes = items_count + max_nof_values / 3;
      break;
    case kPOLYGON:
    case kMULTILINESTRING:
      ndims = 2;
      max_nof_sizes = items_count + 2 * max_nof_values / 3;
      break;
    case kMULTIPOLYGON:
      ndims = 3;
      max_nof_sizes = items_count + max_nof_values;
      break;
    case kTEXT:
      switch (ti.get_compression()) {
        case kENCODING_NONE:
          ndims = 1;
          max_nof_sizes = items_count + max_nof_values / 3;
          break;
        case kENCODING_DICT:
          ndims = 0;
          break;
        default:
          UNREACHABLE();
      }
      break;
    default:
      UNREACHABLE();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t getFlatBufferSize ( int64_t  items_count, int64_t  max_nof_values, const SQLTypeInfo &  ti  )

inline

Definition at line 1841 of file sqltypes.h.

References FlatBufferManager::compute_flatbuffer_size(), FlatBufferManager::computeBufferSizeNestedArray(), GeoPointFormatId, SQLTypeInfo::get_compression(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_type(), getFlatBufferNDimsAndSizes(), kENCODING_GEOINT, kPOINT, and SQLTypeInfo::toValueType().

Referenced by TableFunctionManager::allocate_output_buffers(), and ColumnarResults::ColumnarResults().

                                                        {
  if (ti.get_type() == kPOINT) {
    // to be deprecated
    FlatBufferManager::GeoPoint metadata{items_count,
                                         ti.get_input_srid(),
                                         ti.get_output_srid(),
                                         ti.get_compression() == kENCODING_GEOINT};
    return FlatBufferManager::compute_flatbuffer_size(
        GeoPointFormatId, reinterpret_cast<const int8_t*>(&metadata));
  } else {
    size_t ndims = 0;
    int64_t max_nof_sizes = 0;
    getFlatBufferNDimsAndSizes(items_count, max_nof_values, ti, ndims, max_nof_sizes);
    return FlatBufferManager::computeBufferSizeNestedArray(
        /* ndims= */ ndims,
        /* total_items_count= */ items_count,
        /* total sizes count= */ max_nof_sizes,
        /* total values count= */ max_nof_values,
        ti.toValueType(),
        /* user data size= */ sizeof(SQLTypeInfoLite));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void initializeFlatBuffer ( FlatBufferManager &  m, int64_t  items_count, int64_t  max_nof_values, const SQLTypeInfo &  ti  )

inline

Definition at line 1993 of file sqltypes.h.

References CHECK_EQ, GeoPointFormatId, SQLTypeInfo::get_compression(), SQLTypeInfo::get_input_srid(), get_null_value(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_type(), getFlatBufferNDimsAndSizes(), null_value_t::i8, FlatBufferManager::initialize(), FlatBufferManager::initializeNestedArray(), kENCODING_GEOINT, kPOINT, FlatBufferManager::Success, SQLTypeInfo::toLite(), and SQLTypeInfo::toValueType().

Referenced by TableFunctionManager::allocate_output_buffers(), and ColumnarResults::ColumnarResults().

                                                        {
  if (ti.get_type() == kPOINT) {
    // to be deprecated
    FlatBufferManager::GeoPoint metadata{items_count,
                                         ti.get_input_srid(),
                                         ti.get_output_srid(),
                                         ti.get_compression() == kENCODING_GEOINT};
    m.initialize(GeoPointFormatId, reinterpret_cast<const int8_t*>(&metadata));
  } else {
    size_t ndims = 0;
    int64_t max_nof_sizes = 0;
    getFlatBufferNDimsAndSizes(items_count, max_nof_values, ti, ndims, max_nof_sizes);
    SQLTypeInfoLite ti_lite = ti.toLite();
    null_value_t null_value = get_null_value(ti);
    int8_t* null_value_ptr = &null_value.i8;
    auto status = m.initializeNestedArray(
        /* ndims= */ ndims,
        /* total_items_count= */ items_count,
        /* total_sizes_count= */ max_nof_sizes,
        /* total_values_count= */ max_nof_values,
        ti.toValueType(),
        /* null value buffer=*/null_value_ptr,  // null value buffer size
                                                // is defined by value type
        /* user data buffer=*/reinterpret_cast<const int8_t*>(&ti_lite),
        /* user data buffer size=*/sizeof(SQLTypeInfoLite));
    CHECK_EQ(status, FlatBufferManager::Success);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE constexpr bool is_cuda_compiler ( )

inline

Definition at line 220 of file sqltypes.h.

                                                {
#ifdef __CUDACC__
  return true;
#else
  return false;
#endif
}

constexpr auto is_datetime

(

SQLTypes

type

)

Definition at line 325 of file sqltypes.h.

References kDATE, kTIME, and kTIMESTAMP.

Referenced by ColumnDescriptor::getDefaultValueLiteral(), SQLTypeInfo::is_time(), ArrowForeignStorageBase::replaceNullValues(), RexLiteral::RexLiteral(), and ddl_utils::validate_and_set_fixed_encoding().

                                          {
  return type == kTIME || type == kTIMESTAMP || type == kDATE;
}

Here is the caller graph for this function:

bool IsNullDatum	(	const Datum	d,
		const SQLTypeInfo &	ti
	)

Definition at line 331 of file Datum.cpp.

References DatumEqual(), and NullDatum().

Referenced by anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

                                                           {
  const Datum null_datum = NullDatum(ti);
  return DatumEqual(datum, null_datum, ti);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Datum NullDatum

(

const SQLTypeInfo &

ti

)

Definition at line 288 of file Datum.cpp.

References Datum::bigintval, Datum::boolval, Datum::doubleval, Datum::floatval, import_export::anonymous_namespace{Importer.cpp}::get_type_for_datum(), inline_fixed_encoding_null_val(), Datum::intval, kBIGINT, kBOOLEAN, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, NULL_DOUBLE, NULL_FLOAT, Datum::smallintval, Datum::tinyintval, and run_benchmark_import::type.

Referenced by StringOps_Namespace::compute_jaro_winkler_score(), IsNullDatum(), import_export::NullArray(), and import_export::StringToArray().

                                       {
  Datum d;
  const auto type = get_type_for_datum(ti);
  switch (type) {
    case kBOOLEAN:
      d.boolval = inline_fixed_encoding_null_val(ti);
      break;
    case kBIGINT:
      d.bigintval = inline_fixed_encoding_null_val(ti);
      break;
    case kINT:
      d.intval = inline_fixed_encoding_null_val(ti);
      break;
    case kSMALLINT:
      d.smallintval = inline_fixed_encoding_null_val(ti);
      break;
    case kTINYINT:
      d.tinyintval = inline_fixed_encoding_null_val(ti);
      break;
    case kFLOAT:
      d.floatval = NULL_FLOAT;
      break;
    case kDOUBLE:
      d.doubleval = NULL_DOUBLE;
      break;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      d.bigintval = inline_fixed_encoding_null_val(ti);
      break;
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      throw std::runtime_error("Internal error: geometry type in NullDatum.");
    default:
      throw std::runtime_error("Internal error: invalid type in NullDatum.");
  }
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::ostream& operator<< ( std::ostream &  os, SQLTypes const  sql_type  )

inline

Definition at line 176 of file sqltypes.h.

References toString().

                                                                       {
  os << toString(sql_type);
  return os;
}

Here is the call graph for this function:

std::ostream& operator<< ( std::ostream &  os, EncodingType const  type  )

inline

Definition at line 256 of file sqltypes.h.

References logger::FATAL, kENCODING_ARRAY, kENCODING_ARRAY_DICT, kENCODING_DATE_IN_DAYS, kENCODING_DICT, kENCODING_DIFF, kENCODING_FIXED, kENCODING_GEOINT, kENCODING_LAST, kENCODING_NONE, kENCODING_RL, kENCODING_SPARSE, LOG, and run_benchmark_import::type.

                                                                       {
  switch (type) {
    case kENCODING_NONE:
      os << "NONE";
      break;
    case kENCODING_FIXED:
      os << "FIXED";
      break;
    case kENCODING_RL:
      os << "RL";
      break;
    case kENCODING_DIFF:
      os << "DIFF";
      break;
    case kENCODING_DICT:
      os << "DICT";
      break;
    case kENCODING_SPARSE:
      os << "SPARSE";
      break;
    case kENCODING_GEOINT:
      os << "GEOINT";
      break;
    case kENCODING_DATE_IN_DAYS:
      os << "DATE_IN_DAYS";
      break;
    case kENCODING_ARRAY:
      os << "ARRAY";
      break;
    case kENCODING_ARRAY_DICT:
      os << "ARRAY_DICT";
      break;
    case kENCODING_LAST:
      break;
    default:
      LOG(FATAL) << "Invalid EncodingType: " << type;
  }
  return os;
}

std::ostream& operator<< ( std::ostream &  os, const SQLTypeInfo &  type_info  )

inline

Definition at line 1444 of file sqltypes.h.

References toString().

                                                                            {
  os << toString(type_info);
  return os;
}

Here is the call graph for this function:

SQLTypes string_dict_to_int_type

(

const SQLTypeInfo &

)

Definition at line 565 of file Datum.cpp.

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

Referenced by append_datum(), import_export::anonymous_namespace{Importer.cpp}::get_type_for_datum(), anonymous_namespace{Datum.cpp}::get_type_for_datum(), and foreign_storage::ParquetFixedLengthArrayEncoder::setNullFixedLengthArraySentinel().

                                                        {
  CHECK(ti.is_dict_encoded_string());
  switch (ti.get_size()) {
    case 1:
      return kTINYINT;
    case 2:
      return kSMALLINT;
    case 4:
      return kINT;
    default:
      UNREACHABLE() << "Unexpected string dictionary encoding size: " << ti.get_size();
  }
  return kNULLT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 339 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, kCOLUMN_LIST, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, parse_numeric(), Datum::smallintval, Datum::tinyintval, and to_upper().

Referenced by import_export::TypedImportBuffer::add_value(), import_export::TypedImportBuffer::addDefaultValues(), Parser::FixedPtLiteral::analyze(), Analyzer::Constant::cast_from_string(), data_conversion::StringViewToScalarEncoder< DataType, MetadataType >::convert(), anonymous_namespace{ArrowImporter.h}::ArrowValue< std::string >::operator DATA_TYPE(), populate_TColumn(), import_export::StringToArray(), and ddl_utils::anonymous_namespace{DdlUtils.cpp}::validate_literal().

                                                             {
  Datum d;
  try {
    switch (ti.get_type()) {
      case kARRAY:
      case kCOLUMN:
      case kCOLUMN_LIST:
        break;
      case kBOOLEAN:
        if (s == "t" || s == "T" || s == "1" || to_upper(std::string(s)) == "TRUE") {
          d.boolval = true;
        } else if (s == "f" || s == "F" || s == "0" ||
                   to_upper(std::string(s)) == "FALSE") {
          d.boolval = false;
        } else {
          throw std::runtime_error("Invalid string for boolean " + std::string(s));
        }
        break;
      case kNUMERIC:
      case kDECIMAL:
        d.bigintval = parse_numeric(s, ti);
        break;
      case kBIGINT:
        d.bigintval = parseInteger<int64_t>(s, ti);
        break;
      case kINT:
        d.intval = parseInteger<int32_t>(s, ti);
        break;
      case kSMALLINT:
        d.smallintval = parseInteger<int16_t>(s, ti);
        break;
      case kTINYINT:
        d.tinyintval = parseInteger<int8_t>(s, ti);
        break;
      case kFLOAT:
        d.floatval = std::stof(std::string(s));
        break;
      case kDOUBLE:
        d.doubleval = std::stod(std::string(s));
        break;
      case kTIME:
        d.bigintval = dateTimeParse<kTIME>(s, ti.get_dimension());
        break;
      case kTIMESTAMP:
        d.bigintval = dateTimeParse<kTIMESTAMP>(s, ti.get_dimension());
        break;
      case kDATE:
        d.bigintval = dateTimeParse<kDATE>(s, ti.get_dimension());
        break;
      case kPOINT:
      case kMULTIPOINT:
      case kLINESTRING:
      case kMULTILINESTRING:
      case kPOLYGON:
      case kMULTIPOLYGON:
        throw std::runtime_error("Internal error: geometry type in StringToDatum.");
      default:
        throw std::runtime_error("Internal error: invalid type in StringToDatum: " +
                                 ti.get_type_name());
    }
  } catch (const std::invalid_argument&) {
    throw std::runtime_error("Invalid conversion from string to " + ti.get_type_name());
  } catch (const std::out_of_range&) {
    throw std::runtime_error("Got out of range error during conversion from string to " +
                             ti.get_type_name());
  }
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string toString ( const SQLTypes &  type )

inline

Definition at line 103 of file sqltypes.h.

References logger::FATAL, kARRAY, kBIGINT, kBOOLEAN, kCHAR, kCOLUMN, kCOLUMN_LIST, kCURSOR, kDATE, kDECIMAL, kDOUBLE, kEVAL_CONTEXT_TYPE, kFLOAT, kGEOGRAPHY, kGEOMETRY, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kSQLTYPE_LAST, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, kVOID, LOG, and run_benchmark_import::type.

                                                {
  switch (type) {
    case kNULLT:
      return "NULL";
    case kBOOLEAN:
      return "BOOL";
    case kCHAR:
      return "CHAR";
    case kVARCHAR:
      return "VARCHAR";
    case kNUMERIC:
      return "NUMERIC";
    case kDECIMAL:
      return "DECIMAL";
    case kINT:
      return "INT";
    case kSMALLINT:
      return "SMALLINT";
    case kFLOAT:
      return "FLOAT";
    case kDOUBLE:
      return "DOUBLE";
    case kTIME:
      return "TIME";
    case kTIMESTAMP:
      return "TIMESTAMP";
    case kBIGINT:
      return "BIGINT";
    case kTEXT:
      return "TEXT";
    case kDATE:
      return "DATE";
    case kARRAY:
      return "ARRAY";
    case kINTERVAL_DAY_TIME:
      return "DAY TIME INTERVAL";
    case kINTERVAL_YEAR_MONTH:
      return "YEAR MONTH INTERVAL";
    case kPOINT:
      return "POINT";
    case kMULTIPOINT:
      return "MULTIPOINT";
    case kLINESTRING:
      return "LINESTRING";
    case kMULTILINESTRING:
      return "MULTILINESTRING";
    case kPOLYGON:
      return "POLYGON";
    case kMULTIPOLYGON:
      return "MULTIPOLYGON";
    case kTINYINT:
      return "TINYINT";
    case kGEOMETRY:
      return "GEOMETRY";
    case kGEOGRAPHY:
      return "GEOGRAPHY";
    case kEVAL_CONTEXT_TYPE:
      return "UNEVALUATED ANY";
    case kVOID:
      return "VOID";
    case kCURSOR:
      return "CURSOR";
    case kCOLUMN:
      return "COLUMN";
    case kCOLUMN_LIST:
      return "COLUMN_LIST";
    case kSQLTYPE_LAST:
      break;
  }
  LOG(FATAL) << "Invalid SQL type: " << type;
  return "";
}

std::string toString ( const EncodingType &  type )

inline

Definition at line 296 of file sqltypes.h.

References run_benchmark_import::type.

                                                    {
  std::ostringstream ss;
  ss << type;
  return ss.str();
}

DEVICE void VarlenArray_get_nth ( int8_t *  buf, int  n, ArrayDatum *  result, bool *  is_end  )

inline

Definition at line 1716 of file sqltypes.h.

References CHECK_EQ, FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, and FlatBufferManager::NestedArrayItem< NDIM >::values.

Referenced by ChunkIter_get_nth(), ChunkIter_get_nth_varlen(), and ResultSet::makeVarlenTargetValue().

                                                     {
  FlatBufferManager m{buf};
  FlatBufferManager::Status status{};
  if (m.isNestedArray()) {
    FlatBufferManager::NestedArrayItem<1> item;
    status = m.getItem(n, item);
    if (status == FlatBufferManager::Status::Success) {
      result->length = item.nof_values * m.getValueSize();
      result->pointer = item.values;
      result->is_null = item.is_null;
      *is_end = false;
    } else {
      result->length = 0;
      result->pointer = NULL;
      result->is_null = true;
      *is_end = true;
#ifndef __CUDACC__
      // out of range indexing is equivalent to returning NULL (SQL AT)
      CHECK_EQ(status, FlatBufferManager::Status::ItemUnspecifiedError);
#endif
    }
  } else {
    // to be deprecated
    auto status = m.getItemOld(n, result->length, result->pointer, result->is_null);
    if (status == FlatBufferManager::Status::IndexError) {
      *is_end = true;
      result->length = 0;
      result->pointer = NULL;
      result->is_null = true;
    } else {
      *is_end = false;
#ifndef __CUDACC__
      CHECK_EQ(status, FlatBufferManager::Status::Success);
#endif
    }
  }
}

Here is the caller graph for this function:

DEVICE void VarlenArray_get_nth ( int8_t *  buf, int  n, bool  uncompress, VarlenDatum *  result, bool *  is_end  )

inline

Definition at line 1757 of file sqltypes.h.

References CHECK, CHECK_EQ, VarlenDatum::is_null, VarlenDatum::length, and VarlenDatum::pointer.

                                                     {
  FlatBufferManager m{buf};
  FlatBufferManager::Status status{};
#ifndef __CUDACC__
  CHECK(m.isNestedArray());
#endif
  FlatBufferManager::NestedArrayItem<1> item;
  status = m.getItem(n, item);
  if (status == FlatBufferManager::Status::Success) {
    result->length = item.nof_values * m.getValueSize();
    result->pointer = item.values;
    result->is_null = item.is_null;
    *is_end = false;
#ifndef __CUDACC__
    CHECK(!uncompress);  // NOT IMPLEMENTED
#endif
  } else {
    result->length = 0;
    result->pointer = NULL;
    result->is_null = true;
    *is_end = true;
#ifndef __CUDACC__
    // out of range indexing is equivalent to returning NULL (SQL AT)
    CHECK_EQ(status, FlatBufferManager::Status::IndexError);
#endif
  }
}