lbug::common Namespace Reference

Namespaces
namespace	string_format_detail

Classes
struct	ArrayType
class	ArrayTypeInfo
struct	ArrowResultConfig
class	AuxiliaryBuffer
class	AuxiliaryBufferFactory
class	BinderException
struct	Blob
struct	blob_t
struct	BlobVector
struct	BufferBlock
struct	BufferPoolConstants
struct	CaseInsensitiveStringEquality
struct	CaseInsensitiveStringHashFunction
class	CatalogException
struct	CopyConstants
struct	CSVOption
struct	CSVReaderConfig
struct	DatabaseLifeCycleManager
class	DataChunk
class	DataChunkState
class	Date
struct	date_t
struct	DecimalType
class	DecimalTypeInfo
struct	dtime_t
class	Exception
struct	ExportCSVConstants
struct	ExpressionTypeUtil
class	ExtraTypeInfo
struct	FileScanInfo
struct	FileTypeInfo
struct	FileTypeUtils
struct	HashIndexConstants
struct	HexFormatConstants
class	InMemOverflowBuffer
class	Int128_t
struct	int128_t
class	InternalException
struct	internalID_t
struct	InternalKeyword
class	Interval
struct	interval_t
struct	ku_list_t
struct	ku_string_t
struct	ku_uuid_t
struct	list_entry_t
class	ListAuxiliaryBuffer
struct	ListType
class	ListTypeInfo
class	ListVector
class	LogicalType
struct	LogicalTypeUtils
struct	map_entry_t
struct	MapType
class	MapVector
class	NestedVal
class	NodeOffsetMaskMap
class	NodeVal
	NodeVal represents a node in the graph and stores the nodeID, label and properties of that node. More...
class	NullMask
struct	OrderByConstants
struct	overflow_value_t
class	OverflowException
struct	overload
struct	ParquetConstants
struct	PathSemanticUtils
struct	PhysicalTypeUtils
struct	PlannerKnobs
struct	PortDBConstants
class	RecursiveRelVal
	RecursiveRelVal represents a path in the graph and stores the corresponding rels and nodes of that path. More...
class	RelVal
	RelVal represents a rel in the graph and stores the relID, src/dst nodes and properties of that rel. More...
class	SelectionVector
class	SelectionView
class	SemiMask
struct	SemiMaskUtil
struct	StorageConstants
class	StringAuxiliaryBuffer
class	StringVector
struct	struct_entry_t
class	StructAuxiliaryBuffer
class	StructField
struct	StructType
class	StructTypeInfo
class	StructVector
struct	TableOptionConstants
class	Time
class	Timer
class	Timestamp
struct	timestamp_ms_t
struct	timestamp_ns_t
struct	timestamp_sec_t
struct	timestamp_t
struct	timestamp_tz_t
class	TypeUtils
class	UDTTypeInfo
class	UInt128_t
struct	uint128_t
struct	union_entry_t
struct	UnionType
class	UnionVector
struct	UUID
class	Value
class	ValueVector
struct	WarningConstants

Concepts
concept	SignedIntegerTypes
concept	UnsignedIntegerTypes
concept	IntegerTypes
concept	FloatingPointTypes
concept	NumericTypes
concept	ComparableTypes
concept	HashablePrimitive
concept	IndexHashable
concept	HashableNonNestedTypes
concept	HashableNestedTypes
concept	HashableTypes

Typedefs
template<typename T>
using	case_insensitive_map_t
using	case_insensitve_set_t
using	sel_t = uint64_t
using	hash_t = uint64_t
using	page_idx_t = uint32_t
using	frame_idx_t = page_idx_t
using	page_offset_t = uint32_t
using	file_idx_t = uint32_t
using	page_group_idx_t = uint32_t
using	frame_group_idx_t = page_group_idx_t
using	column_id_t = uint32_t
using	property_id_t = uint32_t
using	idx_t = uint32_t
using	block_idx_t = uint64_t
using	struct_field_idx_t = uint16_t
using	union_field_idx_t = struct_field_idx_t
using	row_idx_t = uint64_t
using	node_group_idx_t = uint64_t
using	partition_idx_t = uint64_t
using	length_t = uint64_t
using	list_size_t = uint32_t
using	sequence_id_t = uint64_t
using	oid_t = uint64_t
using	transaction_t = uint64_t
using	executor_id_t = uint64_t
using	executor_info = std::unordered_map<executor_id_t, uint64_t>
using	table_id_t = oid_t
using	table_id_vector_t = std::vector<table_id_t>
using	table_id_set_t = std::unordered_set<table_id_t>
template<typename T>
using	table_id_map_t = std::unordered_map<table_id_t, T>
using	offset_t = uint64_t
using	nodeID_t = internalID_t
using	relID_t = internalID_t
using	cardinality_t = uint64_t
using	offset_vec_t = std::vector<offset_t>
using	logical_type_vec_t = std::vector<LogicalType>

Enumerations
enum	PageSizeClass : uint8_t { REGULAR_PAGE = 0 , TEMP_PAGE = 1 }
enum class	FStateType : uint8_t { FLAT = 0 , UNFLAT = 1 }
enum class	ExpressionType : uint8_t {   OR = 0 , XOR = 1 , AND = 2 , NOT = 3 ,   EQUALS = 10 , NOT_EQUALS = 11 , GREATER_THAN = 12 , GREATER_THAN_EQUALS = 13 ,   LESS_THAN = 14 , LESS_THAN_EQUALS = 15 , IS_NULL = 50 , IS_NOT_NULL = 51 ,   PROPERTY = 60 , LITERAL = 70 , STAR = 80 , VARIABLE = 90 ,   PATH = 91 , PATTERN = 92 , PARAMETER = 100 , FUNCTION = 110 ,   AGGREGATE_FUNCTION = 130 , SUBQUERY = 190 , CASE_ELSE = 200 , GRAPH = 210 ,   LAMBDA = 220 , INVALID = 255 }
enum class	FileType : uint8_t { UNKNOWN = 0 , CSV = 1 , PARQUET = 2 , NPY = 3 }
enum class	DatePartSpecifier : uint8_t {   YEAR , MONTH , DAY , DECADE ,   CENTURY , MILLENNIUM , QUARTER , MICROSECOND ,   MILLISECOND , SECOND , MINUTE , HOUR ,   WEEK }
enum class	PathSemantic : uint8_t { WALK = 0 , TRAIL = 1 , ACYCLIC = 2 }
enum class	LogicalTypeID : uint8_t {   ANY = 0 , NODE = 10 , REL = 11 , RECURSIVE_REL = 12 ,   SERIAL = 13 , BOOL = 22 , INT64 = 23 , INT32 = 24 ,   INT16 = 25 , INT8 = 26 , UINT64 = 27 , UINT32 = 28 ,   UINT16 = 29 , UINT8 = 30 , INT128 = 31 , DOUBLE = 32 ,   FLOAT = 33 , DATE = 34 , TIMESTAMP = 35 , TIMESTAMP_SEC = 36 ,   TIMESTAMP_MS = 37 , TIMESTAMP_NS = 38 , TIMESTAMP_TZ = 39 , INTERVAL = 40 ,   DECIMAL = 41 , INTERNAL_ID = 42 , UINT128 = 43 , STRING = 50 ,   BLOB = 51 , LIST = 52 , ARRAY = 53 , STRUCT = 54 ,   MAP = 55 , UNION = 56 , POINTER = 58 , UUID = 59 }
enum class	PhysicalTypeID : uint8_t {   ANY = 0 , BOOL = 1 , INT64 = 2 , INT32 = 3 ,   INT16 = 4 , INT8 = 5 , UINT64 = 6 , UINT32 = 7 ,   UINT16 = 8 , UINT8 = 9 , INT128 = 10 , DOUBLE = 11 ,   FLOAT = 12 , INTERVAL = 13 , INTERNAL_ID = 14 , ALP_EXCEPTION_FLOAT = 15 ,   ALP_EXCEPTION_DOUBLE = 16 , UINT128 = 17 , STRING = 20 , LIST = 22 ,   ARRAY = 23 , STRUCT = 24 , POINTER = 25 }
enum class	TypeCategory : uint8_t { INTERNAL = 0 , UDT = 1 }
enum class	FileVersionType : uint8_t { ORIGINAL = 0 , WAL_VERSION = 1 }

Functions
template<typename T, size_t N1, size_t N2>
constexpr std::array< T, N1+N2 >	arrayConcat (const std::array< T, N1 > &arr1, const std::array< T, N2 > &arr2)
void	kuAssertFailureInternal (const char *condition_name, const char *file, int linenr)
template<typename TO, typename FROM>
TO	ku_dynamic_cast (FROM *old)
template<typename TO, typename FROM>
TO	ku_dynamic_cast (FROM &old)
date_t	operator+ (int64_t i, const date_t date)
LBUG_API int128_t	operator+ (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator- (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator* (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator/ (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator% (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator^ (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator& (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator~ (const int128_t &val)
LBUG_API int128_t	operator| (const int128_t &lhs, const int128_t &rhs)
LBUG_API int128_t	operator<< (const int128_t &lhs, int amount)
LBUG_API int128_t	operator>> (const int128_t &lhs, int amount)
LBUG_API bool	operator== (const int128_t &lhs, const int128_t &rhs)
LBUG_API bool	operator!= (const int128_t &lhs, const int128_t &rhs)
LBUG_API bool	operator> (const int128_t &lhs, const int128_t &rhs)
LBUG_API bool	operator>= (const int128_t &lhs, const int128_t &rhs)
LBUG_API bool	operator< (const int128_t &lhs, const int128_t &rhs)
LBUG_API bool	operator<= (const int128_t &lhs, const int128_t &rhs)
template<typename... Args>
std::string	stringFormat (std::string_view format, Args &&... args)
LBUG_API uint128_t	operator+ (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator- (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator* (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator/ (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator% (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator^ (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator& (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator~ (const uint128_t &val)
LBUG_API uint128_t	operator| (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API uint128_t	operator<< (const uint128_t &lhs, int amount)
LBUG_API uint128_t	operator>> (const uint128_t &lhs, int amount)
LBUG_API bool	operator== (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API bool	operator!= (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API bool	operator> (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API bool	operator>= (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API bool	operator< (const uint128_t &lhs, const uint128_t &rhs)
LBUG_API bool	operator<= (const uint128_t &lhs, const uint128_t &rhs)

Variables
const char *	LBUG_VERSION
constexpr double	DEFAULT_HT_LOAD_FACTOR = 1.5
constexpr uint64_t	THREAD_SLEEP_TIME_WHEN_WAITING_IN_MICROS = 500
constexpr uint64_t	DEFAULT_CHECKPOINT_WAIT_TIMEOUT_IN_MICROS = 5000000
constexpr uint64_t	CHUNK_RESIZE_RATIO = 2
constexpr auto	DECIMAL_PRECISION_LIMIT = 38
struct LBUG_API	int128_t
constexpr uint64_t	NULL_BITMASKS_WITH_SINGLE_ONE [64]
constexpr uint64_t	NULL_BITMASKS_WITH_SINGLE_ZERO [64]
const uint64_t	NULL_LOWER_MASKS [65]
const uint64_t	NULL_HIGH_MASKS [65]
constexpr sel_t	INVALID_SEL = UINT64_MAX
constexpr page_idx_t	INVALID_PAGE_IDX = UINT32_MAX
constexpr file_idx_t	INVALID_FILE_IDX = UINT32_MAX
constexpr column_id_t	INVALID_COLUMN_ID = UINT32_MAX
constexpr column_id_t	ROW_IDX_COLUMN_ID = INVALID_COLUMN_ID - 1
constexpr idx_t	INVALID_IDX = UINT32_MAX
constexpr block_idx_t	INVALID_BLOCK_IDX = UINT64_MAX
constexpr struct_field_idx_t	INVALID_STRUCT_FIELD_IDX = UINT16_MAX
constexpr row_idx_t	INVALID_ROW_IDX = UINT64_MAX
constexpr uint32_t	UNDEFINED_CAST_COST = UINT32_MAX
constexpr node_group_idx_t	INVALID_NODE_GROUP_IDX = UINT64_MAX
constexpr partition_idx_t	INVALID_PARTITION_IDX = UINT64_MAX
constexpr length_t	INVALID_LENGTH = UINT64_MAX
constexpr oid_t	INVALID_OID = UINT64_MAX
constexpr transaction_t	INVALID_TRANSACTION = UINT64_MAX
constexpr table_id_t	INVALID_TABLE_ID = INVALID_OID
constexpr offset_t	INVALID_OFFSET = UINT64_MAX
constexpr offset_t	INVALID_LIMIT = UINT64_MAX

Typedef Documentation

block_idx_t

using lbug::common::block_idx_t = uint64_t

cardinality_t

using lbug::common::cardinality_t = uint64_t

case_insensitive_map_t

template<typename T>

using lbug::common::case_insensitive_map_t

Initial value:

 std::unordered_map<std::string, T, CaseInsensitiveStringHashFunction,
    CaseInsensitiveStringEquality>

case_insensitve_set_t

using lbug::common::case_insensitve_set_t

Initial value:

 std::unordered_set<std::string, CaseInsensitiveStringHashFunction,
    CaseInsensitiveStringEquality>

column_id_t

using lbug::common::column_id_t = uint32_t

executor_id_t

using lbug::common::executor_id_t = uint64_t

executor_info

using lbug::common::executor_info = std::unordered_map<executor_id_t, uint64_t>

file_idx_t

using lbug::common::file_idx_t = uint32_t

frame_group_idx_t

using lbug::common::frame_group_idx_t = page_group_idx_t

frame_idx_t

using lbug::common::frame_idx_t = page_idx_t

hash_t

using lbug::common::hash_t = uint64_t

idx_t

using lbug::common::idx_t = uint32_t

length_t

using lbug::common::length_t = uint64_t

list_size_t

using lbug::common::list_size_t = uint32_t

logical_type_vec_t

using lbug::common::logical_type_vec_t = std::vector<LogicalType>

node_group_idx_t

using lbug::common::node_group_idx_t = uint64_t

nodeID_t

using lbug::common::nodeID_t = internalID_t

offset_t

using lbug::common::offset_t = uint64_t

offset_vec_t

using lbug::common::offset_vec_t = std::vector<offset_t>

oid_t

using lbug::common::oid_t = uint64_t

page_group_idx_t

using lbug::common::page_group_idx_t = uint32_t

page_idx_t

using lbug::common::page_idx_t = uint32_t

page_offset_t

using lbug::common::page_offset_t = uint32_t

partition_idx_t

using lbug::common::partition_idx_t = uint64_t

property_id_t

using lbug::common::property_id_t = uint32_t

relID_t

using lbug::common::relID_t = internalID_t

row_idx_t

using lbug::common::row_idx_t = uint64_t

sel_t

using lbug::common::sel_t = uint64_t

sequence_id_t

using lbug::common::sequence_id_t = uint64_t

struct_field_idx_t

using lbug::common::struct_field_idx_t = uint16_t

table_id_map_t

template<typename T>

using lbug::common::table_id_map_t = std::unordered_map<table_id_t, T>

table_id_set_t

using lbug::common::table_id_set_t = std::unordered_set<table_id_t>

table_id_t

using lbug::common::table_id_t = oid_t

table_id_vector_t

using lbug::common::table_id_vector_t = std::vector<table_id_t>

transaction_t

using lbug::common::transaction_t = uint64_t

union_field_idx_t

using lbug::common::union_field_idx_t = struct_field_idx_t

Enumeration Type Documentation

DatePartSpecifier

enum class lbug::common::DatePartSpecifier : uint8_t

strong

Enumerator
YEAR
MONTH
DAY
DECADE
CENTURY
MILLENNIUM
QUARTER
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
WEEK

ExpressionType

enum class lbug::common::ExpressionType : uint8_t

strong

Enumerator
OR
XOR
AND
NOT
EQUALS
NOT_EQUALS
GREATER_THAN
GREATER_THAN_EQUALS
LESS_THAN
LESS_THAN_EQUALS
IS_NULL
IS_NOT_NULL
PROPERTY
LITERAL
STAR
VARIABLE
PATH
PATTERN
PARAMETER
FUNCTION
AGGREGATE_FUNCTION
SUBQUERY
CASE_ELSE
GRAPH
LAMBDA
INVALID

FileType

enum class lbug::common::FileType : uint8_t

strong

Enumerator
UNKNOWN
CSV
PARQUET
NPY

FileVersionType

enum class lbug::common::FileVersionType : uint8_t

strong

Enumerator
ORIGINAL
WAL_VERSION

FStateType

enum class lbug::common::FStateType : uint8_t

strong

Enumerator
FLAT
UNFLAT

LogicalTypeID

enum class lbug::common::LogicalTypeID : uint8_t

strong

Enumerator
ANY
NODE
REL
RECURSIVE_REL
SERIAL
BOOL
INT64
INT32
INT16
INT8
UINT64
UINT32
UINT16
UINT8
INT128
DOUBLE
FLOAT
DATE
TIMESTAMP
TIMESTAMP_SEC
TIMESTAMP_MS
TIMESTAMP_NS
TIMESTAMP_TZ
INTERVAL
DECIMAL
INTERNAL_ID
UINT128
STRING
BLOB
LIST
ARRAY
STRUCT
MAP
UNION
POINTER
UUID

PageSizeClass

enum lbug::common::PageSizeClass : uint8_t

Enumerator
REGULAR_PAGE
TEMP_PAGE

PathSemantic

enum class lbug::common::PathSemantic : uint8_t

strong

Enumerator
WALK
TRAIL
ACYCLIC

PhysicalTypeID

enum class lbug::common::PhysicalTypeID : uint8_t

strong

Enumerator
ANY
BOOL
INT64
INT32
INT16
INT8
UINT64
UINT32
UINT16
UINT8
INT128
DOUBLE
FLOAT
INTERVAL
INTERNAL_ID
ALP_EXCEPTION_FLOAT
ALP_EXCEPTION_DOUBLE
UINT128
STRING
LIST
ARRAY
STRUCT
POINTER

TypeCategory

enum class lbug::common::TypeCategory : uint8_t

strong

Enumerator
INTERNAL
UDT

Function Documentation

arrayConcat()

template<typename T, size_t N1, size_t N2>

std::array< T, N1+N2 > lbug::common::arrayConcat ( const std::array< T, N1 > & arr1, const std::array< T, N2 > & arr2 )

constexpr

ku_dynamic_cast() [1/2]

template<typename TO, typename FROM>

TO lbug::common::ku_dynamic_cast

(

FROM &

old

)

ku_dynamic_cast() [2/2]

template<typename TO, typename FROM>

TO lbug::common::ku_dynamic_cast

(

FROM *

old

)

kuAssertFailureInternal()

void lbug::common::kuAssertFailureInternal ( const char * condition_name, const char * file, int linenr )

inline

operator!=() [1/2]

LBUG_API bool lbug::common::operator!=	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator!=() [2/2]

LBUG_API bool lbug::common::operator!=	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator%() [1/2]

LBUG_API int128_t lbug::common::operator%	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator%() [2/2]

LBUG_API uint128_t lbug::common::operator%	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator&() [1/2]

LBUG_API int128_t lbug::common::operator&	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator&() [2/2]

LBUG_API uint128_t lbug::common::operator&	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator*() [1/2]

LBUG_API int128_t lbug::common::operator*	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator*() [2/2]

LBUG_API uint128_t lbug::common::operator*	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator+() [1/3]

LBUG_API int128_t lbug::common::operator+	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator+() [2/3]

LBUG_API uint128_t lbug::common::operator+	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator+() [3/3]

date_t lbug::common::operator+ ( int64_t i, const date_t date )

inline

operator-() [1/2]

LBUG_API int128_t lbug::common::operator-	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator-() [2/2]

LBUG_API uint128_t lbug::common::operator-	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator/() [1/2]

LBUG_API int128_t lbug::common::operator/	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator/() [2/2]

LBUG_API uint128_t lbug::common::operator/	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator<() [1/2]

LBUG_API bool lbug::common::operator<	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator<() [2/2]

LBUG_API bool lbug::common::operator<	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator<<() [1/2]

LBUG_API int128_t lbug::common::operator<<	(	const int128_t &	lhs,
		int	amount )

operator<<() [2/2]

LBUG_API uint128_t lbug::common::operator<<	(	const uint128_t &	lhs,
		int	amount )

operator<=() [1/2]

LBUG_API bool lbug::common::operator<=	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator<=() [2/2]

LBUG_API bool lbug::common::operator<=	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator==() [1/2]

LBUG_API bool lbug::common::operator==	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator==() [2/2]

LBUG_API bool lbug::common::operator==	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator>() [1/2]

LBUG_API bool lbug::common::operator>	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator>() [2/2]

LBUG_API bool lbug::common::operator>	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator>=() [1/2]

LBUG_API bool lbug::common::operator>=	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator>=() [2/2]

LBUG_API bool lbug::common::operator>=	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator>>() [1/2]

LBUG_API int128_t lbug::common::operator>>	(	const int128_t &	lhs,
		int	amount )

operator>>() [2/2]

LBUG_API uint128_t lbug::common::operator>>	(	const uint128_t &	lhs,
		int	amount )

operator^() [1/2]

LBUG_API int128_t lbug::common::operator^	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator^() [2/2]

LBUG_API uint128_t lbug::common::operator^	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator|() [1/2]

LBUG_API int128_t lbug::common::operator|	(	const int128_t &	lhs,
		const int128_t &	rhs )

operator|() [2/2]

LBUG_API uint128_t lbug::common::operator|	(	const uint128_t &	lhs,
		const uint128_t &	rhs )

operator~() [1/2]

LBUG_API int128_t lbug::common::operator~

(

const int128_t &

val

)

operator~() [2/2]

LBUG_API uint128_t lbug::common::operator~

(

const uint128_t &

val

)

stringFormat()

template<typename... Args>

std::string lbug::common::stringFormat ( std::string_view format, Args &&... args )

inline

Variable Documentation

CHUNK_RESIZE_RATIO

uint64_t lbug::common::CHUNK_RESIZE_RATIO = 2

constexpr

DECIMAL_PRECISION_LIMIT

auto lbug::common::DECIMAL_PRECISION_LIMIT = 38

constexpr

DEFAULT_CHECKPOINT_WAIT_TIMEOUT_IN_MICROS

uint64_t lbug::common::DEFAULT_CHECKPOINT_WAIT_TIMEOUT_IN_MICROS = 5000000

constexpr

DEFAULT_HT_LOAD_FACTOR

double lbug::common::DEFAULT_HT_LOAD_FACTOR = 1.5

constexpr

int128_t

struct LBUG_API lbug::common::int128_t

INVALID_BLOCK_IDX

block_idx_t lbug::common::INVALID_BLOCK_IDX = UINT64_MAX

constexpr

INVALID_COLUMN_ID

column_id_t lbug::common::INVALID_COLUMN_ID = UINT32_MAX

constexpr

INVALID_FILE_IDX

file_idx_t lbug::common::INVALID_FILE_IDX = UINT32_MAX

constexpr

INVALID_IDX

idx_t lbug::common::INVALID_IDX = UINT32_MAX

constexpr

INVALID_LENGTH

length_t lbug::common::INVALID_LENGTH = UINT64_MAX

constexpr

INVALID_LIMIT

offset_t lbug::common::INVALID_LIMIT = UINT64_MAX

constexpr

INVALID_NODE_GROUP_IDX

node_group_idx_t lbug::common::INVALID_NODE_GROUP_IDX = UINT64_MAX

constexpr

INVALID_OFFSET

offset_t lbug::common::INVALID_OFFSET = UINT64_MAX

constexpr

INVALID_OID

oid_t lbug::common::INVALID_OID = UINT64_MAX

constexpr

INVALID_PAGE_IDX

page_idx_t lbug::common::INVALID_PAGE_IDX = UINT32_MAX

constexpr

INVALID_PARTITION_IDX

partition_idx_t lbug::common::INVALID_PARTITION_IDX = UINT64_MAX

constexpr

INVALID_ROW_IDX

row_idx_t lbug::common::INVALID_ROW_IDX = UINT64_MAX

constexpr

INVALID_SEL

sel_t lbug::common::INVALID_SEL = UINT64_MAX

constexpr

INVALID_STRUCT_FIELD_IDX

struct_field_idx_t lbug::common::INVALID_STRUCT_FIELD_IDX = UINT16_MAX

constexpr

INVALID_TABLE_ID

table_id_t lbug::common::INVALID_TABLE_ID = INVALID_OID

constexpr

INVALID_TRANSACTION

transaction_t lbug::common::INVALID_TRANSACTION = UINT64_MAX

constexpr

LBUG_VERSION

const char* lbug::common::LBUG_VERSION

extern

NULL_BITMASKS_WITH_SINGLE_ONE

uint64_t lbug::common::NULL_BITMASKS_WITH_SINGLE_ONE[64]

constexpr

Initial value:

= {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
    0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, 0x80000,
    0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000,
    0x20000000, 0x40000000, 0x80000000, 0x100000000, 0x200000000, 0x400000000, 0x800000000,
    0x1000000000, 0x2000000000, 0x4000000000, 0x8000000000, 0x10000000000, 0x20000000000,
    0x40000000000, 0x80000000000, 0x100000000000, 0x200000000000, 0x400000000000, 0x800000000000,
    0x1000000000000, 0x2000000000000, 0x4000000000000, 0x8000000000000, 0x10000000000000,
    0x20000000000000, 0x40000000000000, 0x80000000000000, 0x100000000000000, 0x200000000000000,
    0x400000000000000, 0x800000000000000, 0x1000000000000000, 0x2000000000000000,
    0x4000000000000000, 0x8000000000000000}

NULL_BITMASKS_WITH_SINGLE_ZERO

uint64_t lbug::common::NULL_BITMASKS_WITH_SINGLE_ZERO[64]

constexpr

Initial value:

= {0xfffffffffffffffe, 0xfffffffffffffffd,
    0xfffffffffffffffb, 0xfffffffffffffff7, 0xffffffffffffffef, 0xffffffffffffffdf,
    0xffffffffffffffbf, 0xffffffffffffff7f, 0xfffffffffffffeff, 0xfffffffffffffdff,
    0xfffffffffffffbff, 0xfffffffffffff7ff, 0xffffffffffffefff, 0xffffffffffffdfff,
    0xffffffffffffbfff, 0xffffffffffff7fff, 0xfffffffffffeffff, 0xfffffffffffdffff,
    0xfffffffffffbffff, 0xfffffffffff7ffff, 0xffffffffffefffff, 0xffffffffffdfffff,
    0xffffffffffbfffff, 0xffffffffff7fffff, 0xfffffffffeffffff, 0xfffffffffdffffff,
    0xfffffffffbffffff, 0xfffffffff7ffffff, 0xffffffffefffffff, 0xffffffffdfffffff,
    0xffffffffbfffffff, 0xffffffff7fffffff, 0xfffffffeffffffff, 0xfffffffdffffffff,
    0xfffffffbffffffff, 0xfffffff7ffffffff, 0xffffffefffffffff, 0xffffffdfffffffff,
    0xffffffbfffffffff, 0xffffff7fffffffff, 0xfffffeffffffffff, 0xfffffdffffffffff,
    0xfffffbffffffffff, 0xfffff7ffffffffff, 0xffffefffffffffff, 0xffffdfffffffffff,
    0xffffbfffffffffff, 0xffff7fffffffffff, 0xfffeffffffffffff, 0xfffdffffffffffff,
    0xfffbffffffffffff, 0xfff7ffffffffffff, 0xffefffffffffffff, 0xffdfffffffffffff,
    0xffbfffffffffffff, 0xff7fffffffffffff, 0xfeffffffffffffff, 0xfdffffffffffffff,
    0xfbffffffffffffff, 0xf7ffffffffffffff, 0xefffffffffffffff, 0xdfffffffffffffff,
    0xbfffffffffffffff, 0x7fffffffffffffff}

NULL_HIGH_MASKS

const uint64_t lbug::common::NULL_HIGH_MASKS[65]

Initial value:

= {0x0, 0x8000000000000000, 0xc000000000000000,
    0xe000000000000000, 0xf000000000000000, 0xf800000000000000, 0xfc00000000000000,
    0xfe00000000000000, 0xff00000000000000, 0xff80000000000000, 0xffc0000000000000,
    0xffe0000000000000, 0xfff0000000000000, 0xfff8000000000000, 0xfffc000000000000,
    0xfffe000000000000, 0xffff000000000000, 0xffff800000000000, 0xffffc00000000000,
    0xffffe00000000000, 0xfffff00000000000, 0xfffff80000000000, 0xfffffc0000000000,
    0xfffffe0000000000, 0xffffff0000000000, 0xffffff8000000000, 0xffffffc000000000,
    0xffffffe000000000, 0xfffffff000000000, 0xfffffff800000000, 0xfffffffc00000000,
    0xfffffffe00000000, 0xffffffff00000000, 0xffffffff80000000, 0xffffffffc0000000,
    0xffffffffe0000000, 0xfffffffff0000000, 0xfffffffff8000000, 0xfffffffffc000000,
    0xfffffffffe000000, 0xffffffffff000000, 0xffffffffff800000, 0xffffffffffc00000,
    0xffffffffffe00000, 0xfffffffffff00000, 0xfffffffffff80000, 0xfffffffffffc0000,
    0xfffffffffffe0000, 0xffffffffffff0000, 0xffffffffffff8000, 0xffffffffffffc000,
    0xffffffffffffe000, 0xfffffffffffff000, 0xfffffffffffff800, 0xfffffffffffffc00,
    0xfffffffffffffe00, 0xffffffffffffff00, 0xffffffffffffff80, 0xffffffffffffffc0,
    0xffffffffffffffe0, 0xfffffffffffffff0, 0xfffffffffffffff8, 0xfffffffffffffffc,
    0xfffffffffffffffe, 0xffffffffffffffff}

NULL_LOWER_MASKS

const uint64_t lbug::common::NULL_LOWER_MASKS[65]

Initial value:

= {0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff,
    0x3ff, 0x7ff, 0xfff, 0x1fff, 0x3fff, 0x7fff, 0xffff, 0x1ffff, 0x3ffff, 0x7ffff, 0xfffff,
    0x1fffff, 0x3fffff, 0x7fffff, 0xffffff, 0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff,
    0x3fffffff, 0x7fffffff, 0xffffffff, 0x1ffffffff, 0x3ffffffff, 0x7ffffffff, 0xfffffffff,
    0x1fffffffff, 0x3fffffffff, 0x7fffffffff, 0xffffffffff, 0x1ffffffffff, 0x3ffffffffff,
    0x7ffffffffff, 0xfffffffffff, 0x1fffffffffff, 0x3fffffffffff, 0x7fffffffffff, 0xffffffffffff,
    0x1ffffffffffff, 0x3ffffffffffff, 0x7ffffffffffff, 0xfffffffffffff, 0x1fffffffffffff,
    0x3fffffffffffff, 0x7fffffffffffff, 0xffffffffffffff, 0x1ffffffffffffff, 0x3ffffffffffffff,
    0x7ffffffffffffff, 0xfffffffffffffff, 0x1fffffffffffffff, 0x3fffffffffffffff,
    0x7fffffffffffffff, 0xffffffffffffffff}

ROW_IDX_COLUMN_ID

column_id_t lbug::common::ROW_IDX_COLUMN_ID = INVALID_COLUMN_ID - 1

constexpr

THREAD_SLEEP_TIME_WHEN_WAITING_IN_MICROS

uint64_t lbug::common::THREAD_SLEEP_TIME_WHEN_WAITING_IN_MICROS = 500

constexpr

UNDEFINED_CAST_COST

uint32_t lbug::common::UNDEFINED_CAST_COST = UINT32_MAX

constexpr