C++ SDK Documentation
12.0.0
|
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 |
Defines classes for Vertica User Defined Functions
typedef int64 Vertica::DateADT |
The value in DateADT is the number of days
typedef int64 Vertica::Interval |
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
typedef int64 Vertica::IntervalYM |
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
typedef int64 Vertica::TimeADT |
TimeADT represents time within a day
The value in TimeADT number of microseconds within 24 hours
typedef int64 Vertica::Timestamp |
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
typedef int64 Vertica::TimestampTz |
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
typedef int64 Vertica::TimeTzADT |
Represents time within a day in a timezone
The value in TimeADT consists of 2 parts:
enum Vertica::InputState |
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.
enum Vertica::StreamState |
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.
enum Vertica::volatility |
Enums to allow programmatic specification of volatility and strictness
|
inline |
Allow free serializer
Referenced by Vertica::SimpleArchiveOut::operator<<(), and Vertica::SimpleArchiveIn::operator>>().
void Vertica::bserialize | ( | Archive & | ar, |
T(&) | x[n], | ||
const unsigned int | version | ||
) |
Handle arrays
void Vertica::copyBlockColumn | ( | DstBlock & | dstblock, |
const SrcBlock & | srcblock, | ||
size_t | dstIdx, | ||
size_t | srcIdx | ||
) |
Function to copy a column from one block to another
|
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().
|
inlinestatic |
Convert Unix time_t to Date
|
inlinestatic |
Get the GMT time of the TimeTz value (in microseconds)
|
inlinestatic |
Get the time from a Time value
|
inlinestatic |
Convert Unix time_t to Time
|
inlinestatic |
keep the microseconds while converting!
|
inlinestatic |
Convert Unix time_t to Timestamp
|
inlinestatic |
double to timestamp tz to TimestampTz without truncation
|
inlinestatic |
Convert Unix time_t to TimestampTz
|
inlinestatic |
Get the time at the timezone specified in TimeTz value itself (in microseconds)
|
inlinestatic |
Convert Timestamp to unix time in seconds WITHOUT TRUNCATING MICROSECONDS
|
inlinestatic |
Convert Date to Unix Time
|
inlinestatic |
Convert Time to Unix Time
|
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)
|
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.
format | a printf style format string specifying the log message format. |
VNumericTemp<Alloc> Vertica::operator* | ( | const VNumeric & | left, |
const VNumeric & | right | ||
) |
Multiplies two VNumerics and returns a temporary numeric
stringtype Vertica::operator+ | ( | const VString & | left, |
const VString & | right | ||
) |
Concatenate VStrings into a std::string
VNumericTemp<Alloc> Vertica::operator+ | ( | const VNumeric & | left, |
const VNumeric & | right | ||
) |
Adds two VNumerics and returns a temporary numeric
VNumericTemp<Alloc> Vertica::operator- | ( | const VNumeric & | left, |
const VNumeric & | right | ||
) |
Subtracts one VNumeric from another and returns a temporary numeric
VNumericTemp<Alloc> Vertica::operator/ | ( | const VNumeric & | left, |
const VNumeric & | right | ||
) |
Divides one VNumeric from another and returns a temporary numeric
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
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
|
inlinestatic |
Produce a Time value
|
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
|
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().