C++ SDK Documentation  12.0.0
Vertica Namespace Reference

Classes

struct  AESKey
 
class  AggregateFunction
 Interface for User-Defined Aggregate Function (UDAF). A UDAF operates on one column of data and returns one column of data. More...
 
class  AggregateFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated AggregateFunction. More...
 
class  AnalyticFunction
 Interface for User-Defined Analytic Function (UDAnF). A UDAnF operates on rows of data and returns rows of data, not necessarily 1:1. More...
 
class  AnalyticFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated AnalyticFunction. More...
 
class  AnalyticPartitionReader
 Provides an iterator-based read interface over all the partition_by keys, order_by keys, and function arguments in a partition. More...
 
class  AnalyticPartitionWriter
 Partition writer for all input data in a single partition. It automatically makes space as needed. More...
 
class  BasePartitionWriterColumn
 Base class for vectorized writing to columns. Efficiently writes each element in a single column. More...
 
struct  BlobCreateOptions
 
struct  BlobRequest
 
struct  BlockFormatter
 
struct  BlockFormatterCout
 
class  BlockReader
 Iterator interface for reading rows in a Vertica block. More...
 
class  BlockWriter
 Iterator interface for writing rows to a Vertica block. More...
 
class  ClientMessage
 Holds the contents of a user-defined message to be reported by a UDx. More...
 
class  ColumnTypes
 Represents (unsized) types of the columns used as input/output of a User Defined Function/Transform Function. More...
 
struct  ConcurrencyModel
 
class  CounterController
 Class to interact with counters. More...
 
class  CursorRequest
 
class  CursorTransformFunction
 Interface for Cursored UDTF, the actual code to process a partition of data coming in as a stream, or to access projection cursors.
 
class  CursorTransformFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated CursorTransformFunction.
 
struct  DataBuffer
 
class  DefaultSourceIterator
 
struct  defserializer
 
struct  defserializer< false, false, Archive, T >
 
struct  defserializer< false, true, Archive, T >
 
struct  defserializer< true, false, Archive, T >
 
class  ExecutorParamWriter
 An ExecutorParamWriter is a ParamWriter whose scope is limited to a single executor node - it will never be serialized for transfer to a different node. As a result, any object which is allocated from a Vertica memory pool (i.e. a ServerInterface's allocator object) can have its address saved in the ExecutorParamWriter (see setPointer()), and be safely retrieved later on (see getPointer()) from a different API call in the same query. More...
 
class  ExecutorPlanContext
 An ExecutorPlanContext is a PlanContext object whose scope is limited to a single executor node: it and its parameters will never be serialized. In addition to providing information about nodes involved in a query, it indicates how many threads are available and allocated for a load. More...
 
struct  Field
 
class  Fields
 
class  FilterFactory
 Produces and initializes UDFilters to transform input data before parsing. More...
 
union  FIunion
 
class  FunctionFactory
 
class  IntermediateAggs
 A wrapper around a single intermediate aggregate value. More...
 
class  IterativeSourceFactory
 Source factory that works with a SourceIterator to produce UDSources. More...
 
struct  LengthBuffer
 
struct  LibraryRegistrar
 
class  Model
 
class  MultiPhaseTransformFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated multi-phase transform function. This class is similar to, but not a subclass of, TransformFunctionFactory. More...
 
class  MultipleIntermediateAggs
 A wrapper around multiple intermediate aggregates. More...
 
class  NodeSpecifyingPlanContext
 Interface that allows storage of query-plan state, when different parts of query planning take place on different computers. More...
 
struct  OpenOptions
 
struct  ParallelismInfo
 
class  ParamReader
 Provides read access to a set of named parameters. This class provides type-specific methods to retrieve values. More...
 
class  ParamWriter
 Provides write access to a set of named parameters. This class extends ParamReader to add type-specific methods to write values. More...
 
class  ParserFactory
 Produces and initializes UDParsers to parse input into tuples. More...
 
struct  PartitionOrderColumnInfo
 Represents the partition by and order by column information for each phase in a multi-phase transform function. More...
 
class  PartitionReader
 provides an iterator-based read interface over all input data in a single partition. Automatically fetches data a block-at-a-time, as needed. More...
 
class  PartitionWriter
 Provides an iterator-based write interface over output data for a single partition. Automatically makes space a block-at-a-time, as needed. More...
 
class  PartitionWriterColumn
 
class  PartitionWriterColumns
 PartitionWriterColumns allow column-by-column access to PartitionWriter data. More...
 
class  PartitionWriterNumericColumn
 
class  PartitionWriterStringColumn
 
class  PartitionWriterUuidColumn
 
class  PerColumnParamReader
 A wrapper around a map from column to ParamReader. More...
 
class  PlanContext
 Shared query-plan state, used when different parts of query planning take place on different nodes. For example, if some work is done on the query initiator node and some is done on each node executing the query, this class stores shared state. More...
 
struct  Portion
 
struct  RejectedRecord
 
class  ScalarFunction
 Interface for User-Defined Scalar Function (UDSF). A UDSF produces a single value from a row of data. More...
 
class  ScalarFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated ScalarFunction. More...
 
class  ScopedTimerCounter
 Class to start an execution timer on construction and to automatically stop the timer on deconstruction or when manually called with stop() More...
 
class  ServerInterface
 Provides UDxs with access to the Vertica server. More...
 
class  SessionParamReaderMap
 This class provides an interface for reading the Used defined session parameters. More...
 
class  SessionParamWriterMap
 This class provides an interface for writing the Used defined session parameters. More...
 
struct  SimpleArchiveIn
 
struct  SimpleArchiveOut
 
class  SizedColumnTypes
 Represents types and information to determine the size of the columns as input/output of a User Defined Function/Transform. More...
 
class  SourceFactory
 Produces and initializes UDSources to process input data sources. More...
 
class  SourceIterator
 Constructs a set of Sources to be used by an IterativeSourceFactory. More...
 
struct  SplitArchiver
 
struct  SplitArchiver< false, Archive, T >
 
struct  SplitArchiver< true, Archive, T >
 
class  StreamWriter
 Provides an iterator-based write interface over output data for a stream of blocks. Automatically makes space a block-at-a-time, as needed. More...
 
class  TransformFunction
 Interface for User-Defined Transform Function (UDTF). A UDTF operates on a table segment and returns zero or more rows of data. More...
 
class  TransformFunctionFactory
 Interface for declaring parameters and return types for, and instantiating, an associated TransformFunction. More...
 
class  TransformFunctionPhase
 Interface to provide compile-time information for a single phase of a multi-phase user-defined transform function. More...
 
class  UDChunker
 Separates parser input into chunks at record boundaries, allowing parsing to proceed in parallel. More...
 
class  UDFileOperator
 
class  UDFileSystem
 
class  UDFileSystemFactory
 
class  UDFileSystemStats
 
class  UDFilter
 Reads input data from a UDSource or another UDFilter and transforms it. More...
 
class  UDKeyManager
 
class  UDKeyManagerFactory
 
class  UDLFactory
 
class  UDParser
 Parses an input stream into Vertica tuples (rows to be inserted into a table). More...
 
class  UDSource
 Acquires data from an external source (such as a file or URL) and produces that data in a streaming manner. More...
 
class  UDxBlobCursor
 Class for reading and writing to a blob. A blob is divided internally into several chunks, this gives a cursor to one of the chunks. To change which chunk the cursor points to, the user may call a function 'switchToChunk(i)'. It also contains metadata about its blob.
 
struct  UDxCounterRequest
 
class  UDxCursor
 
class  UDXFactory
 Parent class for UDx factories; not intended for direct use by applications. More...
 
class  UDXFunction
 
class  UDXObject
 Base class for Vertica User-Defined extensions (the function classes themselves). Not intended for direct use by applications. More...
 
struct  UDxRegistrar
 
class  UnsizedUDSource
 Base class for UDSource. Use, with IterativeSourceFactory, if computing the size of a source up front would be prohibitively expensive, or if the number of distinct sources would be prohibitively large to use the standard API. Typically you should use UDSource instead. More...
 
class  ValueRangeReader
 This class represents the value ranges of the arguments of a UDSF, one range per argument. More...
 
class  ValueRangeWriter
 This class represents the output value range of a UDSF. More...
 
class  VerticaBlock
 : Represents an in-memory block of tuples More...
 
struct  VerticaBuildInfo
 
class  VerticaType
 Represents types of data that are passed into and returned back from user's code. More...
 
class  VerticaValueRange
 This class represents value ranges used in analyzing the output of UDSFs. A range is expressed as a minimum/maximum value (inclusive) pair. More...
 
class  VInterval
 Representation of an Interval in Vertica. More...
 
class  VIntervalYM
 Representation of an IntervalYM in Vertica. An Interval can be broken up into years and months. More...
 
class  VNumeric
 Representation of NUMERIC, fixed point data types in Vertica. More...
 
class  VNumericTemp
 
struct  VResources
 
class  VString
 Representation of a String in Vertica. All character data is internally encoded as UTF-8 characters and is not NULL terminated. More...
 
class  VTAllocator
 A pool-based allocator that is provided to simplify memory management for UDF implementors. More...
 
class  VUuid
 Representation of Universally Unique Identifier (UUID) data type in Vertica. More...
 

Typedefs

typedef int64 DateADT
 
typedef long double ifloat
 vertica 80-bit intermediate result
 
typedef ScalarFunction IndexListScalarFunction
 
typedef signed short int16
 signed 16-bit integer
 
typedef signed int int32
 signed 32-bit integer
 
typedef signed long long int64
 signed 64-bit integer
 
typedef signed char int8
 8-bit integer
 
typedef int64 Interval
 
typedef int64 IntervalYM
 
typedef std::pair< std::string,
struct::stat > 
NameStatPair
 
typedef std::vector< BlobRequest > RequestedBlobs
 
typedef std::vector
< UDxCounterRequest
RequestedCounters
 
typedef std::vector
< CursorRequest > 
RequestedCursors
 
typedef std::map< std::string,
int > 
RequestedNodes
 
typedef int64 TimeADT
 
typedef int64 Timestamp
 
typedef int64 TimestampTz
 Vertica timestamp data type. More...
 
typedef int64 TimeTzADT
 
typedef unsigned short uint16
 unsigned 16-bit integer
 
typedef unsigned int uint32
 unsigned 32-bit integer
 
typedef unsigned long long uint64
 unsigned 64-bit integer
 
typedef unsigned char uint8
 unsigned 8-bit integer
 
typedef uint8 vbool
 vertica 8-bit boolean (t,f,null)
 
typedef double vfloat
 Represents Vertica 64-bit floating-point type for NULL checking use vfloatIsNull(), assignment to NULL use vfloat_null for NaN checking use vfloatIsNaN(), assignment to NaN use vfloat_NaN.
 
typedef signed long long vint
 vertica 64-bit integer (not int64)
 
typedef unsigned long long vpos
 64-bit vertica position
 
typedef uint32 vsize
 vertica 32-bit block size
 
typedef int(* VT_ERRMSG )(const char *fmt,...)
 
typedef void(* VT_THROW_EXCEPTION )(int errcode, const std::string &message, const char *filename, int lineno)
 
typedef void(* VT_THROW_INTERNAL_EXCEPTION )(int errcode, const std::string &message, const std::string &info, const char *filename, int lineno, const char *funcname)
 

Enumerations

enum  ClientMessageErrorLevel { MSG_INFO = 0, MSG_NOTICE = 1, MSG_WARNING = 2, MSG_ERROR = 3 }
 The possible types of messages to be reported from a UDx.
 
enum  DTtype {
  RESERV = 0, MONTH = 1, YEAR = 2, DAY = 3,
  NEG_INTERVAL = 4, TZ = 5, DTZ = 6, DTZMOD = 7,
  IGNORE_DTF = 8, AMPM = 9, HOUR = 10, MINUTE = 11,
  SECOND = 12, DOY = 13, DOW = 14, UNITS = 15,
  ADBC = 16, AGO = 17, ISODATE = 20, ISOTIME = 21,
  UNKNOWN_FIELD = 31
}
 
enum  InputState {
  OK = 0, END_OF_FILE = 1, END_OF_CHUNK = 2, START_OF_PORTION = 3,
  END_OF_PORTION = 4
}
 
enum  StreamState {
  INPUT_NEEDED = 0, OUTPUT_NEEDED = 1, DONE = 2, REJECT = 3,
  KEEP_GOING = 4, CHUNK_ALIGNED = 5
}
 
enum  strictness { DEFAULT_STRICTNESS, CALLED_ON_NULL_INPUT, RETURN_NULL_ON_NULL_INPUT, STRICT }
 
enum  UDXDebugLevels { UDXDebugging_WARNING = 0x0001, UDXDebugging_INFO = 0x0002, UDXDebugging_BASIC = 0x0008, UDXDebugging_ALL = 0xFFFF }
 
enum  VBool { VFalse = 0, VTrue = 1, VUnknown = 2 }
 Enumeration for Boolean data values.
 
enum  volatility { DEFAULT_VOLATILITY, VOLATILE, IMMUTABLE, STABLE }
 

Functions

template<class Archive , class T >
void bserialize (Archive &ar, T &val, const uint serializer_version)
 
template<class Archive , typename T , size_t n>
void bserialize (Archive &ar, T(&x)[n], const unsigned int version)
 
template<typename DstBlock , typename SrcBlock >
void copyBlockColumn (DstBlock &dstblock, const SrcBlock &srcblock, size_t dstIdx, size_t srcIdx)
 
DateADT dateIn (const char *str, bool report_error)
 
DateADT dateInFormatted (const char *str, const std::string format, bool report_error)
 
DateADT dateInNoTzNameCheck (const char *str, bool report_error)
 
int32 dateToChar (DateADT d, char *res, int32 max_size, int32 date_style, bool report_error)
 
static void describeIntervalTypeMod (char *result, Typemod typemod)
 
void dummy ()
 
UserLibraryManifest * get_library_manifest ()
 
void get_vertica_build_info (VerticaBuildInfo &vbi)
 
static DateADT getDateFromUnixTime (time_t time)
 
static int64 getGMTTz (TimeTzADT time)
 
static uint64 getTime (TimeADT time)
 
static TimeADT getTimeFromUnixTime (time_t time)
 
static Timestamp getTimestampFromUnixDouble (double time)
 
static Timestamp getTimestampFromUnixTime (time_t time)
 
static TimestampTz getTimestampTzFromUnixDouble (double time)
 
static TimestampTz getTimestampTzFromUnixTime (time_t time)
 
static int64 getTimeTz (TimeTzADT time)
 
std::string getUDTypeName (Oid typeOid)
 
Oid getUDTypeOid (const char *typeName)
 
Oid getUDTypeUnderlyingOid (Oid typeOid)
 
vint getUDxDebugLogLevel ()
 
static double getUnixDoubleFromTimestamp (Timestamp timestamp)
 
static time_t getUnixTimeFromDate (DateADT date)
 
static time_t getUnixTimeFromTime (TimeADT t)
 
static time_t getUnixTimeFromTimestamp (Timestamp timestamp)
 
static time_t getUnixTimeFromTimestampTz (TimestampTz timestamp)
 
static int32 getZoneTz (TimeTzADT time)
 
UserLibraryManifest & GlobalLibraryManifest ()
 
Interval intervalIn (const char *str, Typemod typmod, bool report_error)
 
Interval intervalIn (const char *str, int32 precision, bool report_error)
 
int32 intervalToChar (Interval i, Typemod typmod, char *res, int32 max_size, int32 date_style, bool report_error)
 
int32 intervalToChar (Interval i, int32 precision, char *res, int32 max_size, int32 date_style, bool report_error)
 
bool isUDType (Oid typeOid)
 
void log (const char *format,...) __attribute__((format(printf
 
int makeErrMsg (std::basic_ostream< char, std::char_traits< char > > &err_msg, const char *fmt,...)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator* (const VNumeric &left, const VNumeric &right)
 
template<typename stringtype = std::string>
stringtype operator+ (const VString &left, const VString &right)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator+ (const VNumeric &left, const VNumeric &right)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator- (const VNumeric &left, const VNumeric &right)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator/ (const VNumeric &left, const VNumeric &right)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator<< (const VNumeric &operand, unsigned shift)
 
template<class Alloc = std::allocator<uint64>>
VNumericTemp< Alloc > operator>> (const VNumeric &operand, unsigned shift)
 
static TimeADT setTime (int64 time)
 
static TimeTzADT setTimeTz (int64 time, int32 zone)
 
void setup_global_function_pointers (VT_THROW_EXCEPTION throw_exception, VT_THROW_INTERNAL_EXCEPTION throw_internal_exception, VT_ERRMSG server_errmsg, ServerFunctions *fns)
 
TimeADT timeIn (const char *str, Typemod typmod, bool report_error)
 
TimeADT timeIn (const char *str, int32 precision, bool report_error)
 
TimeADT timeInFormatted (const char *str, Typemod typmod, const std::string format, bool report_error)
 
TimeADT timeInFormatted (const char *str, int32 precision, const std::string format, bool report_error)
 
TimeADT timeInNoTzNameCheck (const char *str, Typemod typmod, bool report_error)
 
TimeADT timeInNoTzNameCheck (const char *str, int32 precision, bool report_error)
 
Timestamp timestampIn (const char *str, Typemod typmod, bool report_error)
 
Timestamp timestampIn (const char *str, int32 precision, bool report_error)
 
Timestamp timestampInFormatted (const char *str, Typemod typmod, const std::string format, bool report_error)
 
Timestamp timestampInFormatted (const char *str, int32 precision, const std::string format, bool report_error)
 
Timestamp timestampInNoTzNameCheck (const char *str, Typemod typmod, bool report_error)
 
Timestamp timestampInNoTzNameCheck (const char *str, int32 precision, bool report_error)
 
int32 timestampToChar (Timestamp dt, char *res, int32 max_size, int32 date_style, bool report_error)
 
TimestampTz timestamptzIn (const char *str, Typemod typmod, bool report_error)
 
TimestampTz timestamptzIn (const char *str, int32 precision, bool report_error)
 
TimestampTz timestamptzInFormatted (const char *str, Typemod typmod, const std::string format, bool report_error)
 
TimestampTz timestamptzInFormatted (const char *str, int32 precision, const std::string format, bool report_error)
 
TimestampTz timestamptzInNoTzNameCheck (const char *str, Typemod typmod, bool report_error)
 
TimestampTz timestamptzInNoTzNameCheck (const char *str, int32 precision, bool report_error)
 
int32 timestamptzToChar (TimestampTz dtz, char *res, int32 max_size, int32 date_style, bool report_error)
 
int32 timeToChar (TimeADT t, char *res, int32 max_size, bool report_error)
 
TimeTzADT timetzIn (const char *str, Typemod typmod, bool report_error)
 
TimeTzADT timetzIn (const char *str, int32 precision, bool report_error)
 
TimeTzADT timetzInFormatted (const char *str, Typemod typmod, const std::string format, bool report_error)
 
TimeTzADT timetzInFormatted (const char *str, int32 precision, const std::string format, bool report_error)
 
TimeTzADT timetzInNoTzNameCheck (const char *str, Typemod typmod, bool report_error)
 
TimeTzADT timetzInNoTzNameCheck (const char *str, int32 precision, bool report_error)
 
int32 timetzToChar (TimeTzADT tz, char *res, int32 max_size, bool report_error)
 
bool vfixedIsNull (const void *ptr, size_t len)
 
bool vfloatIsNaN (const vfloat *f)
 
bool vfloatIsNaN (const vfloat f)
 
bool vfloatIsNull (const vfloat *vf)
 
bool vfloatIsNull (const vfloat vf)
 
void vsmemclr (void *dst, size_t len)
 
void vsmemcpy (void *dst, const void *src, size_t len)
 
bool vsmemne (const void *p1, const void *p2, size_t len)
 Version of memcmp for detecting not equal only. Inline function for comparing small things of arbitrary length.
 
template<typename TRET >
TRET * vt_createFuncObject (VTAllocator *allocator)
 
template<typename TRET , typename T1 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1)
 
template<typename TRET , typename T1 , typename T2 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2)
 
template<typename TRET , typename T1 , typename T2 , typename T3 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
 
template<typename TRET , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
TRET * vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
 

Variables

const uint8 byte_null = 0xff
 Indicates NULL byte.
 
const char char_null = 0xff
 Indicates NULL char.
 
static const uint64 INVALID_UINT64 = std::numeric_limits<uint64>::max()
 
static const size_t UDFS_DEFAULT_FANOUT_LEN = 3
 
static const size_t UDFS_DEFAULT_FANOUT_MOD = 1000
 
const vbool vbool_false = VFalse
 Value for Boolean FALSE.
 
const vbool vbool_null = VUnknown
 Value for Boolean NULL.
 
const vbool vbool_true = VTrue
 Value for Boolean TRUE.
 
ServerFunctions * VERTICA_INTERNAL_fns = NULL
 
const vfloat vfloat_null = vfn.vf
 
union Vertica::FIunion vfn = {0x7ffffffffffffffeLL}
 
union FIunion vfNaN = { static_cast<vint>(0xFFF8000000000000LL) }
 
const vint vint_null = 0x8000000000000000LL
 Value for Integer NULLs.
 
VT_ERRMSG vt_server_errmsg = 0
 
VT_THROW_EXCEPTION vt_throw_exception = 0
 
VT_THROW_INTERNAL_EXCEPTION vt_throw_internal_exception = 0
 

Detailed Description

Defines classes for Vertica User Defined Functions

Typedef Documentation

The value in DateADT is the number of days

Represents delta time.

The value in Interval is number of microseconds, which is limited to +/- 2^63-1 microseconds = 106751991 days 4 hours 54.775807 seconds or +/-9223372036854775807 months = 768614336404564650 years 7 months

Interval can be directly added/subtracted from Timestamp/TimestampTz to have a meaningful result

Represents delta time.

The value in IntervalYM is number of months

So Interval can be directly added/subtracted from Timestamp/TimestampTz to have a meaningful result, but IntervalYM cannot

TimeADT represents time within a day

The value in TimeADT number of microseconds within 24 hours

Represents absolute time and date.

The value in Timestamp is the number of microseconds since 2000-01-01 00:00:00 with no timezone implied

Vertica timestamp data type.

Represents absolute time and date with time zone.

The value in TimestampTz is the number of microseconds since 2000-01-01 00:00:00 GMT

Represents time within a day in a timezone

The value in TimeADT consists of 2 parts:

  1. The lower 24 bits (defined as ZoneFieldWidth) contains the timezone plus 24 hours, specified in seconds SQL-2008 limits the timezone itself to range between +/-14 hours
  2. The rest of higher bits contains the time in GMT, value specified as number of microseconds within 24 hours

Enumeration Type Documentation

InputState

Applies only to input streams; namely, UDFilter and UDParser.

OK Currently at the start of or in the middle of a stream.

END_OF_FILE Reached the end of the input stream. No further data is available. Returning a StreamState of INPUT_NEEDED at this point is invalid, as there is no more input.

END_OF_CHUNK Reached the end of an input chunk. Applies only to a parser and only when fed by a Chunker, it means the current data block ends on a record boundary. In this state a parser should consume all data in the block before returning from process.

START_OF_PORTION Used when a load stack is apportioned. This mode indicates input does not start at the beginning of a source. Typical response of a parser is to find the first end-of-record and return PORTION_START. Subsequent calls to process will use InputState = OK, until the end of the portion/source is reached.

END_OF_PORTION Used when a load stack is apportioned. This mode indicates the underlying source has reached the end of its allotted portion. The typical response from a parser is to finish the last record it started but proceed no farther.

StreamState

Indicates the state of a stream after process() has handled some input and some output data.

The different enum values have the following meanings:

INPUT_NEEDED
Indicates that a stream is unable to continue without being given more input. It may not have consumed all of its available input yet. It does not need to have consumed every byte of input. Not valid for output-only streams, ie., UDSources.

OUTPUT_NEEDED
Indicates that a stream is unable to write more output without being given a new or larger output buffer. Basically that it has "filled" the buffer as much as it is reasonably able to (which may be every byte full, some bytes full, even completely empty – in which case Vertica assumes that the UDL needs a larger buffer). Not valid for input-only streams, ie., UDParsers.

DONE
The stream has completed; it will not be writing any more output nor consuming any more input.

REJECT
Only valid for UDParsers. Indicates that the last row the Parser consumed is invalid and should be processed as a rejected row.

KEEP_GOING
The stream has not filled all of its output buffer or consumed all of its input buffer, but would like to yield to the server. It is important to yield back to the server occasionally so that command have an opportunity to be canceled. Additionally, yielding to the server helps you to avoid a tight loop when waiting for data to arrive.

Return KEEP_GOING if a stream cannot proceed for an extended period of time (e.g. while waiting on an external operation to complete). This allows the stream to be called again, and prevents it from blocking indefinitely. Pointers into input or output buffers remain valid, and buffer offsets can be set.

CHUNK_ALIGNED
Used by UDChunker only. The chunker has found as many rows as possible in current block, and would like to hand off to parser a data block that is aligned with record boundary (input offset points to the start of the row after last row found in current block).

See the UDSource, UDFilter, and UDParser classes for how these streams are used.

Bit mast for communicatnig the available UDx debug logging levels.

Enums to allow programmatic specification of volatility and strictness

Function Documentation

template<class Archive , class T >
void Vertica::bserialize ( Archive &  ar,
T &  val,
const uint  serializer_version 
)
inline
template<class Archive , typename T , size_t n>
void Vertica::bserialize ( Archive &  ar,
T(&)  x[n],
const unsigned int  version 
)

Handle arrays

template<typename DstBlock , typename SrcBlock >
void Vertica::copyBlockColumn ( DstBlock &  dstblock,
const SrcBlock &  srcblock,
size_t  dstIdx,
size_t  srcIdx 
)

Function to copy a column from one block to another

static void Vertica::describeIntervalTypeMod ( char *  result,
Typemod  typemod 
)
inlinestatic

Format interval "<subtype>" where <subtype> often starts with a space Call with char buf[64] to hold the result.

Referenced by Vertica::VerticaType::getPrettyPrintStr().

static DateADT Vertica::getDateFromUnixTime ( time_t  time)
inlinestatic

Convert Unix time_t to Date

static int64 Vertica::getGMTTz ( TimeTzADT  time)
inlinestatic

Get the GMT time of the TimeTz value (in microseconds)

static uint64 Vertica::getTime ( TimeADT  time)
inlinestatic

Get the time from a Time value

static TimeADT Vertica::getTimeFromUnixTime ( time_t  time)
inlinestatic

Convert Unix time_t to Time

static Timestamp Vertica::getTimestampFromUnixDouble ( double  time)
inlinestatic

keep the microseconds while converting!

static Timestamp Vertica::getTimestampFromUnixTime ( time_t  time)
inlinestatic

Convert Unix time_t to Timestamp

static TimestampTz Vertica::getTimestampTzFromUnixDouble ( double  time)
inlinestatic

double to timestamp tz to TimestampTz without truncation

static TimestampTz Vertica::getTimestampTzFromUnixTime ( time_t  time)
inlinestatic

Convert Unix time_t to TimestampTz

static int64 Vertica::getTimeTz ( TimeTzADT  time)
inlinestatic

Get the time at the timezone specified in TimeTz value itself (in microseconds)

static double Vertica::getUnixDoubleFromTimestamp ( Timestamp  timestamp)
inlinestatic

Convert Timestamp to unix time in seconds WITHOUT TRUNCATING MICROSECONDS

static time_t Vertica::getUnixTimeFromDate ( DateADT  date)
inlinestatic

Convert Date to Unix Time

static time_t Vertica::getUnixTimeFromTime ( TimeADT  t)
inlinestatic

Convert Time to Unix Time

static time_t Vertica::getUnixTimeFromTimestamp ( Timestamp  timestamp)
inlinestatic

Convert Timestamp to Unix time_t value (which is number of seconds since the Unix epoch) The internal representation of Timestamps is number of microseconds since the Postgres epoch date. This will truncate the timestamp to number of seconds (instead of microseconds)

static int32 Vertica::getZoneTz ( TimeTzADT  time)
inlinestatic

Get timezone from a TimeTz value (in seconds) (seconds field should be 0)

Referenced by getTimeTz().

void Vertica::log ( const char *  format,
  ... 
)

Write a message to the vertica.log system log.

Parameters
formata printf style format string specifying the log message format.
template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator* ( const VNumeric &  left,
const VNumeric &  right 
)

Multiplies two VNumerics and returns a temporary numeric

template<typename stringtype = std::string>
stringtype Vertica::operator+ ( const VString &  left,
const VString &  right 
)

Concatenate VStrings into a std::string

template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator+ ( const VNumeric &  left,
const VNumeric &  right 
)

Adds two VNumerics and returns a temporary numeric

template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator- ( const VNumeric &  left,
const VNumeric &  right 
)

Subtracts one VNumeric from another and returns a temporary numeric

template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator/ ( const VNumeric &  left,
const VNumeric &  right 
)

Divides one VNumeric from another and returns a temporary numeric

template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator<< ( const VNumeric &  operand,
unsigned  shift 
)

Shift the bits of a VNumeric left the indicated number of bits; returns the result in a VNumericTemp

template<class Alloc = std::allocator<uint64>>
VNumericTemp<Alloc> Vertica::operator>> ( const VNumeric &  operand,
unsigned  shift 
)

Shift the bits of a VNumeric right the indicated number of bits; returns the result in a VNumericTemp

static TimeADT Vertica::setTime ( int64  time)
inlinestatic

Produce a Time value

static TimeTzADT Vertica::setTimeTz ( int64  time,
int32  zone 
)
inlinestatic

Produce a TimeTz value from time (in microseconds) at a timezone (in seconds, seconds field does not need to be 0 as zoneinfo record all those historical change, and historical change may have hour/minute/seconds adjustment

void Vertica::vsmemcpy ( void *  dst,
const void *  src,
size_t  len 
)
inline

Version of memcpy optimized for vertica's small data types. Inline function for copying small things of arbitrary length.

This copy is forward-only (i.e. lower addresses are read and written first) - callers may depend on that.

NOTE: If you are using this function in a C++ UDX AND compiling with -O3 make sure you disable tree-vectorize optimization (-fno-tree-vectorize)

NOTE: Avoid using pragma and function attributes here as it may have a negative impact on inlining.

Referenced by Vertica::VUuid::copy().