Kùzu C++ API
Loading...
Searching...
No Matches
kuzu::common Namespace Reference

Namespaces

namespace  string_format_detail
 

Classes

struct  ArrayType
 
class  ArrayTypeInfo
 
class  ArrowColumnAuxiliaryBuffer
 
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
 
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  FileTypeInfo
 
struct  FileTypeUtils
 
struct  HashIndexConstants
 
struct  HexFormatConstants
 
struct  ImportDBConstants
 
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  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
 
struct  overload
 
struct  ParquetConstants
 
struct  PathSemanticUtils
 
struct  PhysicalTypeUtils
 
struct  PlannerKnobs
 
struct  ReaderConfig
 
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
 
struct  StorageConstants
 
class  StringAuxiliaryBuffer
 
class  StringVector
 
struct  struct_entry_t
 
class  StructAuxiliaryBuffer
 
class  StructField
 
struct  StructType
 
class  StructTypeInfo
 
class  StructVector
 
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
 
struct  union_entry_t
 
struct  UnionType
 
class  UnionVector
 
struct  UUID
 
class  Value
 
class  ValueVector
 
struct  WarningConstants
 

Concepts

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 idx_t = uint32_t
 
using block_idx_t = uint64_t
 
using struct_field_idx_t = uint8_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 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  PathSemantic : uint8_t { WALK = 0 , TRAIL = 1 , ACYCLIC = 2 }
 
enum class  FileType : uint8_t {
  UNKNOWN = 0 , CSV = 1 , PARQUET = 2 , NPY = 3 ,
  TURTLE = 4 , NQUADS = 5 , NTRIPLES = 6
}
 
enum class  StatementType : uint8_t {
  QUERY = 0 , CREATE_TABLE = 1 , DROP = 2 , ALTER = 3 ,
  COPY_TO = 19 , COPY_FROM = 20 , STANDALONE_CALL = 21 , STANDALONE_CALL_FUNCTION = 22 ,
  EXPLAIN = 23 , CREATE_MACRO = 24 , TRANSACTION = 30 , EXTENSION = 31 ,
  EXPORT_DATABASE = 32 , IMPORT_DATABASE = 33 , ATTACH_DATABASE = 34 , DETACH_DATABASE = 35 ,
  USE_DATABASE = 36 , CREATE_SEQUENCE = 37 , CREATE_TYPE = 39
}
 
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 , 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 , 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)
 
KUZU_API int128_t operator+ (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator- (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator* (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator/ (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator% (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator^ (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator& (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator~ (const int128_t &val)
 
KUZU_API int128_t operator| (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API int128_t operator<< (const int128_t &lhs, int amount)
 
KUZU_API int128_t operator>> (const int128_t &lhs, int amount)
 
KUZU_API bool operator== (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API bool operator!= (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API bool operator> (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API bool operator>= (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API bool operator< (const int128_t &lhs, const int128_t &rhs)
 
KUZU_API bool operator<= (const int128_t &lhs, const int128_t &rhs)
 
template<typename... Args>
std::string stringFormat (std::string_view format, Args... args)
 

Variables

const char * KUZU_VERSION
 
constexpr uint64_t DEFAULT_VECTOR_CAPACITY = static_cast<uint64_t>(1) << VECTOR_CAPACITY_LOG_2
 
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 KUZU_API int128_t
 
enum KUZU_API DatePartSpecifier
 
enum KUZU_API MONTH
 
enum KUZU_API DAY
 
enum KUZU_API DECADE
 
enum KUZU_API CENTURY
 
enum KUZU_API MILLENNIUM
 
enum KUZU_API QUARTER
 
enum KUZU_API MICROSECOND
 
enum KUZU_API MILLISECOND
 
enum KUZU_API SECOND
 
enum KUZU_API MINUTE
 
enum KUZU_API HOUR
 
enum KUZU_API WEEK
 
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 = UINT8_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 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 kuzu::common::block_idx_t = uint64_t

◆ cardinality_t

using kuzu::common::cardinality_t = uint64_t

◆ case_insensitive_map_t

template<typename T >
using kuzu::common::case_insensitive_map_t
Initial value:
std::unordered_map<std::string, T, CaseInsensitiveStringHashFunction,
CaseInsensitiveStringEquality>

◆ case_insensitve_set_t

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

◆ column_id_t

using kuzu::common::column_id_t = uint32_t

◆ executor_id_t

using kuzu::common::executor_id_t = uint64_t

◆ executor_info

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

◆ file_idx_t

using kuzu::common::file_idx_t = uint32_t

◆ frame_group_idx_t

◆ frame_idx_t

◆ hash_t

using kuzu::common::hash_t = uint64_t

◆ idx_t

using kuzu::common::idx_t = uint32_t

◆ length_t

using kuzu::common::length_t = uint64_t

◆ list_size_t

using kuzu::common::list_size_t = uint32_t

◆ logical_type_vec_t

◆ node_group_idx_t

◆ nodeID_t

◆ offset_t

using kuzu::common::offset_t = uint64_t

◆ oid_t

using kuzu::common::oid_t = uint64_t

◆ page_group_idx_t

◆ page_idx_t

using kuzu::common::page_idx_t = uint32_t

◆ page_offset_t

using kuzu::common::page_offset_t = uint32_t

◆ partition_idx_t

◆ relID_t

◆ row_idx_t

using kuzu::common::row_idx_t = uint64_t

◆ sel_t

using kuzu::common::sel_t = uint64_t

◆ sequence_id_t

using kuzu::common::sequence_id_t = uint64_t

◆ struct_field_idx_t

◆ table_id_map_t

template<typename T >
using kuzu::common::table_id_map_t = std::unordered_map<table_id_t, T>

◆ table_id_set_t

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

◆ table_id_t

◆ table_id_vector_t

◆ transaction_t

using kuzu::common::transaction_t = uint64_t

◆ union_field_idx_t

Enumeration Type Documentation

◆ ExpressionType

enum class kuzu::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 kuzu::common::FileType : uint8_t
strong
Enumerator
UNKNOWN 
CSV 
PARQUET 
NPY 
TURTLE 
NQUADS 
NTRIPLES 

◆ FileVersionType

enum class kuzu::common::FileVersionType : uint8_t
strong
Enumerator
ORIGINAL 
WAL_VERSION 

◆ FStateType

enum class kuzu::common::FStateType : uint8_t
strong
Enumerator
FLAT 
UNFLAT 

◆ LogicalTypeID

enum class kuzu::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 
STRING 
BLOB 
LIST 
ARRAY 
STRUCT 
MAP 
UNION 
POINTER 
UUID 

◆ PageSizeClass

Enumerator
REGULAR_PAGE 
TEMP_PAGE 

◆ PathSemantic

enum class kuzu::common::PathSemantic : uint8_t
strong
Enumerator
WALK 
TRAIL 
ACYCLIC 

◆ PhysicalTypeID

enum class kuzu::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 
STRING 
LIST 
ARRAY 
STRUCT 
POINTER 

◆ StatementType

enum class kuzu::common::StatementType : uint8_t
strong
Enumerator
QUERY 
CREATE_TABLE 
DROP 
ALTER 
COPY_TO 
COPY_FROM 
STANDALONE_CALL 
STANDALONE_CALL_FUNCTION 
EXPLAIN 
CREATE_MACRO 
TRANSACTION 
EXTENSION 
EXPORT_DATABASE 
IMPORT_DATABASE 
ATTACH_DATABASE 
DETACH_DATABASE 
USE_DATABASE 
CREATE_SEQUENCE 
CREATE_TYPE 

◆ TypeCategory

enum class kuzu::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 > kuzu::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 kuzu::common::ku_dynamic_cast ( FROM & old)

◆ ku_dynamic_cast() [2/2]

template<typename TO , typename FROM >
TO kuzu::common::ku_dynamic_cast ( FROM * old)

◆ kuAssertFailureInternal()

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

◆ operator!=()

KUZU_API bool kuzu::common::operator!= ( const int128_t & lhs,
const int128_t & rhs )

◆ operator%()

KUZU_API int128_t kuzu::common::operator% ( const int128_t & lhs,
const int128_t & rhs )

◆ operator&()

KUZU_API int128_t kuzu::common::operator& ( const int128_t & lhs,
const int128_t & rhs )

◆ operator*()

KUZU_API int128_t kuzu::common::operator* ( const int128_t & lhs,
const int128_t & rhs )

◆ operator+() [1/2]

KUZU_API int128_t kuzu::common::operator+ ( const int128_t & lhs,
const int128_t & rhs )

◆ operator+() [2/2]

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

◆ operator-()

KUZU_API int128_t kuzu::common::operator- ( const int128_t & lhs,
const int128_t & rhs )

◆ operator/()

KUZU_API int128_t kuzu::common::operator/ ( const int128_t & lhs,
const int128_t & rhs )

◆ operator<()

KUZU_API bool kuzu::common::operator< ( const int128_t & lhs,
const int128_t & rhs )

◆ operator<<()

KUZU_API int128_t kuzu::common::operator<< ( const int128_t & lhs,
int amount )

◆ operator<=()

KUZU_API bool kuzu::common::operator<= ( const int128_t & lhs,
const int128_t & rhs )

◆ operator==()

KUZU_API bool kuzu::common::operator== ( const int128_t & lhs,
const int128_t & rhs )

◆ operator>()

KUZU_API bool kuzu::common::operator> ( const int128_t & lhs,
const int128_t & rhs )

◆ operator>=()

KUZU_API bool kuzu::common::operator>= ( const int128_t & lhs,
const int128_t & rhs )

◆ operator>>()

KUZU_API int128_t kuzu::common::operator>> ( const int128_t & lhs,
int amount )

◆ operator^()

KUZU_API int128_t kuzu::common::operator^ ( const int128_t & lhs,
const int128_t & rhs )

◆ operator|()

KUZU_API int128_t kuzu::common::operator| ( const int128_t & lhs,
const int128_t & rhs )

◆ operator~()

KUZU_API int128_t kuzu::common::operator~ ( const int128_t & val)

◆ stringFormat()

template<typename... Args>
std::string kuzu::common::stringFormat ( std::string_view format,
Args... args )
inline

Formats args according to format. Accepts {} for formatting the argument and {{}} for a literal {}. Formatting is done with std::ostream::operator<<.

Variable Documentation

◆ CENTURY

enum KUZU_API kuzu::common::CENTURY

◆ CHUNK_RESIZE_RATIO

uint64_t kuzu::common::CHUNK_RESIZE_RATIO = 2
constexpr

◆ DatePartSpecifier

enum KUZU_API kuzu::common::DatePartSpecifier
strong

◆ DAY

enum KUZU_API kuzu::common::DAY

◆ DECADE

enum KUZU_API kuzu::common::DECADE

◆ DECIMAL_PRECISION_LIMIT

auto kuzu::common::DECIMAL_PRECISION_LIMIT = 38
constexpr

◆ DEFAULT_CHECKPOINT_WAIT_TIMEOUT_IN_MICROS

uint64_t kuzu::common::DEFAULT_CHECKPOINT_WAIT_TIMEOUT_IN_MICROS = 5000000
constexpr

◆ DEFAULT_HT_LOAD_FACTOR

double kuzu::common::DEFAULT_HT_LOAD_FACTOR = 1.5
constexpr

◆ DEFAULT_VECTOR_CAPACITY

uint64_t kuzu::common::DEFAULT_VECTOR_CAPACITY = static_cast<uint64_t>(1) << VECTOR_CAPACITY_LOG_2
constexpr

◆ HOUR

enum KUZU_API kuzu::common::HOUR

◆ int128_t

struct KUZU_API kuzu::common::int128_t

◆ INVALID_BLOCK_IDX

block_idx_t kuzu::common::INVALID_BLOCK_IDX = UINT64_MAX
constexpr

◆ INVALID_COLUMN_ID

column_id_t kuzu::common::INVALID_COLUMN_ID = UINT32_MAX
constexpr

◆ INVALID_FILE_IDX

file_idx_t kuzu::common::INVALID_FILE_IDX = UINT32_MAX
constexpr

◆ INVALID_IDX

idx_t kuzu::common::INVALID_IDX = UINT32_MAX
constexpr

◆ INVALID_LIMIT

offset_t kuzu::common::INVALID_LIMIT = UINT64_MAX
constexpr

◆ INVALID_NODE_GROUP_IDX

node_group_idx_t kuzu::common::INVALID_NODE_GROUP_IDX = UINT64_MAX
constexpr

◆ INVALID_OFFSET

offset_t kuzu::common::INVALID_OFFSET = UINT64_MAX
constexpr

◆ INVALID_OID

oid_t kuzu::common::INVALID_OID = UINT64_MAX
constexpr

◆ INVALID_PAGE_IDX

page_idx_t kuzu::common::INVALID_PAGE_IDX = UINT32_MAX
constexpr

◆ INVALID_PARTITION_IDX

partition_idx_t kuzu::common::INVALID_PARTITION_IDX = UINT64_MAX
constexpr

◆ INVALID_ROW_IDX

row_idx_t kuzu::common::INVALID_ROW_IDX = UINT64_MAX
constexpr

◆ INVALID_SEL

sel_t kuzu::common::INVALID_SEL = UINT64_MAX
constexpr

◆ INVALID_STRUCT_FIELD_IDX

struct_field_idx_t kuzu::common::INVALID_STRUCT_FIELD_IDX = UINT8_MAX
constexpr

◆ INVALID_TABLE_ID

table_id_t kuzu::common::INVALID_TABLE_ID = INVALID_OID
constexpr

◆ INVALID_TRANSACTION

transaction_t kuzu::common::INVALID_TRANSACTION = UINT64_MAX
constexpr

◆ KUZU_VERSION

const char* kuzu::common::KUZU_VERSION
extern

◆ MICROSECOND

enum KUZU_API kuzu::common::MICROSECOND

◆ MILLENNIUM

enum KUZU_API kuzu::common::MILLENNIUM

◆ MILLISECOND

enum KUZU_API kuzu::common::MILLISECOND

◆ MINUTE

enum KUZU_API kuzu::common::MINUTE

◆ MONTH

enum KUZU_API kuzu::common::MONTH

◆ NULL_BITMASKS_WITH_SINGLE_ONE

uint64_t kuzu::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 kuzu::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 kuzu::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 kuzu::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}

◆ QUARTER

enum KUZU_API kuzu::common::QUARTER

◆ ROW_IDX_COLUMN_ID

column_id_t kuzu::common::ROW_IDX_COLUMN_ID = INVALID_COLUMN_ID - 1
constexpr

◆ SECOND

enum KUZU_API kuzu::common::SECOND

◆ THREAD_SLEEP_TIME_WHEN_WAITING_IN_MICROS

uint64_t kuzu::common::THREAD_SLEEP_TIME_WHEN_WAITING_IN_MICROS = 500
constexpr

◆ UNDEFINED_CAST_COST

uint32_t kuzu::common::UNDEFINED_CAST_COST = UINT32_MAX
constexpr

◆ WEEK

enum KUZU_API kuzu::common::WEEK