Classes
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	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

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...

class	FilterFactory
	Produces and initializes UDFilters to transform input data before parsing. More...

union	FIunion

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	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	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	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...

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...

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	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	UDXObject
	Base class for Vertica User-Defined extensions (the function classes themselves). Not intended for direct use by applications. More...

class	UDXObjectCancelable

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...

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 uint8	byte
	unsigned 8-bit integer

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	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
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, int32 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)

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, int32 typmod, bool report_error)

int32	intervalToChar (Interval i, int32 typmod, 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,...)

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, int32 typmod, bool report_error)

TimeADT	timeInFormatted (const char *str, int32 typmod, const std::string format, bool report_error)

TimeADT	timeInNoTzNameCheck (const char *str, int32 typmod, bool report_error)

Timestamp	timestampIn (const char *str, int32 typmod, bool report_error)

Timestamp	timestampInFormatted (const char *str, int32 typmod, const std::string format, bool report_error)

Timestamp	timestampInNoTzNameCheck (const char *str, int32 typmod, bool report_error)

int32	timestampToChar (Timestamp dt, char *res, int32 max_size, int32 date_style, bool report_error)

TimestampTz	timestamptzIn (const char *str, int32 typmod, bool report_error)

TimestampTz	timestamptzInFormatted (const char *str, int32 typmod, const std::string format, bool report_error)

TimestampTz	timestamptzInNoTzNameCheck (const char *str, int32 typmod, 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, int32 typmod, bool report_error)

TimeTzADT	timetzInFormatted (const char *str, int32 typmod, const std::string format, bool report_error)

TimeTzADT	timetzInNoTzNameCheck (const char *str, int32 typmod, 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 byte	byte_null = 0xff
	Indicates NULL byte.

const char	char_null = 0xff
	Indicates NULL char.

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

const union Vertica::FIunion	vfn = {0x7ffffffffffffffeLL}

const 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

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 Not commonly used. The stream has neither filled all of its output buffer nor consumed all of its input buffer, but would like to yield to the server. Typically it has neither consumed data nor produced data. This state should be used instead of a "wait" loop; a stream that is waiting for some external operation to complete should periodically return KEEP_GOING rather than simply blocking forever.

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

static void Vertica::describeIntervalTypeMod	(	char *	result,
		int32	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

Referenced by getUnixTimeFromDate().

static int64 Vertica::getGMTTz ( TimeTzADT time )

inlinestatic

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

Referenced by getZoneTz().

static uint64 Vertica::getTime ( TimeADT time )

inlinestatic

Get the time from a Time value

Referenced by setTime().

static TimeADT Vertica::getTimeFromUnixTime ( time_t time )

inlinestatic

Convert Unix time_t to Time

Referenced by getUnixTimeFromTime().

static Timestamp Vertica::getTimestampFromUnixDouble ( double time )

inlinestatic

keep the microseconds while converting!

Referenced by getTimestampFromUnixTime().

static Timestamp Vertica::getTimestampFromUnixTime ( time_t time )

inlinestatic

Convert Unix time_t to Timestamp

Referenced by getUnixDoubleFromTimestamp().

static TimestampTz Vertica::getTimestampTzFromUnixDouble ( double time )

inlinestatic

double to timestamp tz to TimestampTz without truncation

Referenced by getTimestampTzFromUnixTime().

static TimestampTz Vertica::getTimestampTzFromUnixTime ( time_t time )

inlinestatic

Convert Unix time_t to TimestampTz

Referenced by getTimestampFromUnixDouble().

static int64 Vertica::getTimeTz ( TimeTzADT time )

inlinestatic

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

Referenced by getGMTTz().

static double Vertica::getUnixDoubleFromTimestamp ( Timestamp timestamp )

inlinestatic

Convert Timestamp to unix time in seconds WITHOUT TRUNCATING MICROSECONDS

Referenced by getUnixTimeFromTimestamp().

static time_t Vertica::getUnixTimeFromDate ( DateADT date )

inlinestatic

Convert Date to Unix Time

Referenced by getTimestampTzFromUnixDouble().

static time_t Vertica::getUnixTimeFromTime ( TimeADT t )

inlinestatic

Convert Time to Unix Time

Referenced by getDateFromUnixTime().

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)

Referenced by getTime().

static int32 Vertica::getZoneTz ( TimeTzADT time )

inlinestatic

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

Referenced by getTimeTz(), and setTimeTz().

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.

Referenced by Vertica::ServerInterface::getParamReader().

static TimeADT Vertica::setTime ( int64 time )

inlinestatic

Produce a Time value

Referenced by getTimeTz(), Vertica::PartitionWriter::setInt(), Vertica::BlockWriter::setNull(), and Vertica::PartitionWriter::setNull().

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 More information is at VER-26360 )

Referenced by Vertica::PartitionWriter::setInt(), Vertica::BlockWriter::setNull(), and Vertica::PartitionWriter::setNull().

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.

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

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation