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.
class	AggregateFunctionFactory
	Interface for declaring parameters and return types for, and instantiating, an associated AggregateFunction.
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.
class	AnalyticFunctionFactory
	Interface for declaring parameters and return types for, and instantiating, an associated AnalyticFunction.
class	AnalyticPartitionReader
	Provides an iterator-based read interface over all the partition_by keys, order_by keys, and function arguments in a partition.
class	AnalyticPartitionWriter
	Partition writer for all input data in a single partition. It automatically makes space as needed.
class	BasePartitionWriterColumn
	Base class for vectorized writing to columns. Efficiently writes each element in a single column.
struct	BlobCreateOptions
struct	BlobRequest
struct	BlockFormatter
struct	BlockFormatterCout
class	BlockReader
	Iterator interface for reading rows in a Vertica block.
class	BlockWriter
	Iterator interface for writing rows to a Vertica block.
class	ClientMessage
	Holds the contents of a user-defined message to be reported by a UDx.
class	ColumnTypes
	Represents (unsized) types of the columns used as input/output of a User Defined Function/Transform Function.
struct	ConcurrencyModel
class	CounterController
	Class to interact with counters.
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
struct	defserializer
struct	defserializer
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.
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.
struct	Field
class	Fields
class	FilterFactory
	Produces and initializes UDFilters to transform input data before parsing.
union	FIunion
class	FunctionFactory
class	IntermediateAggs
	A wrapper around a single intermediate aggregate value.
class	IterativeSourceFactory
	Source factory that works with a SourceIterator to produce UDSources.
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.
class	MultipleIntermediateAggs
	A wrapper around multiple intermediate aggregates.
class	NodeSpecifyingPlanContext
	Interface that allows storage of query-plan state, when different parts of query planning take place on different computers.
struct	OpenOptions
struct	ParallelismInfo
class	ParamReader
	Provides read access to a set of named parameters. This class provides type-specific methods to retrieve values.
class	ParamWriter
	Provides write access to a set of named parameters. This class extends ParamReader to add type-specific methods to write values.
class	ParserFactory
	Produces and initializes UDParsers to parse input into tuples.
struct	PartitionOrderColumnInfo
	Represents the partition by and order by column information for each phase in a multi-phase transform function.
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.
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.
class	PartitionWriterColumn
class	PartitionWriterColumns
	PartitionWriterColumns allow column-by-column access to PartitionWriter data.
class	PartitionWriterNumericColumn
class	PartitionWriterStringColumn
class	PartitionWriterUuidColumn
class	PerColumnParamReader
	A wrapper around a map from column to ParamReader.
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.
struct	Portion
struct	RejectedRecord
class	ScalarFunction
	Interface for User-Defined Scalar Function (UDSF). A UDSF produces a single value from a row of data.
class	ScalarFunctionFactory
	Interface for declaring parameters and return types for, and instantiating, an associated ScalarFunction.
class	ScopedTimerCounter
	Class to start an execution timer on construction and to automatically stop the timer on deconstruction or when manually called with stop()
class	ServerInterface
	Provides UDxs with access to the Vertica server.
class	SessionParamReaderMap
	This class provides an interface for reading the Used defined session parameters.
class	SessionParamWriterMap
	This class provides an interface for writing the Used defined session parameters.
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.
class	SourceFactory
	Produces and initializes UDSources to process input data sources.
class	SourceIterator
	Constructs a set of Sources to be used by an IterativeSourceFactory.
struct	SplitArchiver
struct	SplitArchiver
struct	SplitArchiver
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.
class	TransformFunction
	Interface for User-Defined Transform Function (UDTF). A UDTF operates on a table segment and returns zero or more rows of data.
class	TransformFunctionFactory
	Interface for declaring parameters and return types for, and instantiating, an associated TransformFunction.
class	TransformFunctionPhase
	Interface to provide compile-time information for a single phase of a multi-phase user-defined transform function.
class	UDChunker
	Separates parser input into chunks at record boundaries, allowing parsing to proceed in parallel.
class	UDFileOperator
class	UDFileSystem
class	UDFileSystemFactory
class	UDFileSystemStats
class	UDFilter
	Reads input data from a UDSource or another UDFilter and transforms it.
class	UDKeyManager
class	UDKeyManagerFactory
class	UDLFactory
class	UDParser
	Parses an input stream into Vertica tuples (rows to be inserted into a table).
class	UDSource
	Acquires data from an external source (such as a file or URL) and produces that data in a streaming manner.
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.
class	UDXFunction
class	UDXObject
	Base class for Vertica User-Defined extensions (the function classes themselves). Not intended for direct use by applications.
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.
class	ValueRangeReader
	This class represents the value ranges of the arguments of a UDSF, one range per argument.
class	ValueRangeWriter
	This class represents the output value range of a UDSF.
class	VerticaBlock
	: Represents an in-memory block of tuples
struct	VerticaBuildInfo
class	VerticaType
	Represents types of data that are passed into and returned back from user's code.
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.
class	VInterval
	Representation of an Interval in Vertica.
class	VIntervalYM
	Representation of an IntervalYM in Vertica. An Interval can be broken up into years and months.
class	VNumeric
	Representation of NUMERIC, fixed point data types in Vertica.
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.
class	VTAllocator
	A pool-based allocator that is provided to simplify memory management for UDF implementors.
class	VUuid
	Representation of Universally Unique Identifier (UUID) data type in Vertica.

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	NameStatPair
typedef std::vector	RequestedBlobs
typedef std::vector	RequestedCounters
typedef std::vector	RequestedCursors
typedef std::map	RequestedNodes
typedef int64	TimeADT
typedef int64	Timestamp
typedef int64	TimestampTz
	Vertica timestamp data type.
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
void	bserialize (Archive &ar, T &val, const uint serializer_version)
template
void	bserialize (Archive &ar, T(&x)[n], const unsigned int version)
template
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 > &err_msg, const char *fmt,...)
template>
VNumericTemp	operator* (const VNumeric &left, const VNumeric &right)
template
stringtype	operator+ (const VString &left, const VString &right)
template>
VNumericTemp	operator+ (const VNumeric &left, const VNumeric &right)
template>
VNumericTemp	operator- (const VNumeric &left, const VNumeric &right)
template>
VNumericTemp	operator/ (const VNumeric &left, const VNumeric &right)
template>
VNumericTemp	operator>
VNumericTemp	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
TRET *	vt_createFuncObject (VTAllocator *allocator)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
template
TRET *	vt_createFuncObject (VTAllocator *allocator, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
template
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::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(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

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:

• 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

• The rest of higher bits contains the time in GMT, value specified as number of microseconds within 24 hours

Enumeration Type Documentation

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.

enum Vertica::UDXDebugLevels

Bit mast for communicatnig the available UDx debug logging levels.

enum Vertica::volatility

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 Allow free serializer

Referenced by Vertica::SimpleArchiveOut::operator>().

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 "" where 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

• format: a printf style format string specifying the log message format.

template<class Alloc = std::allocator<uint64>>

VNumericTemp 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 Vertica::operator+(const VNumeric & left, const VNumeric & right)

Adds two VNumerics and returns a temporary numeric

template<class Alloc = std::allocator<uint64>>

VNumericTemp 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 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 Vertica::operator

template<class Alloc = std::allocator<uint64>>

VNumericTemp 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().