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

Namespaces

namespace  numeric_utils
 
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  ConflictActionUtil
 
struct  CopyConstants
 
struct  CSVOption
 
struct  CSVReaderConfig
 
class  DataChunk
 
class  DataChunkState
 
class  Date
 
struct  date_t
 
struct  DecimalType
 
class  DecimalTypeInfo
 
class  Deserializer
 
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  MaskCollection
 
struct  MaskData
 
struct  MaskUtil
 
class  Metric
 
class  NestedVal
 
class  NodeOffsetLevelSemiMask
 
class  NodeSemiMask
 
class  NodeVal
 NodeVal represents a node in the graph and stores the nodeID, label and properties of that node. More...
 
class  NodeVectorLevelSemiMask
 
class  NullMask
 
class  NumericMetric
 
struct  OrderByConstants
 
struct  overflow_value_t
 
struct  overload
 
struct  ParquetConstants
 
struct  PathSemanticUtils
 
struct  PhysicalTypeUtils
 
struct  PlannerKnobs
 
class  ProgressBar
 Progress bar for tracking the progress of a pipeline. Prints the progress of each query pipeline and the overall progress. More...
 
class  ProgressBarDisplay
 Interface for displaying progress of a pipeline and a query. More...
 
struct  RdfConstants
 
class  RdfVariant
 
struct  RdfVariantVector
 
class  Reader
 
struct  ReaderConfig
 
class  RecursiveRelVal
 RecursiveRelVal represents a path in the graph and stores the corresponding rels and nodes of that path. More...
 
struct  RelMultiplicityUtils
 
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  Serializer
 
struct  StorageConstants
 
class  StringAuxiliaryBuffer
 
class  StringVector
 
struct  struct_entry_t
 
class  StructAuxiliaryBuffer
 
class  StructField
 
struct  StructType
 
class  StructTypeInfo
 
class  StructVector
 
struct  TableTypeUtils
 
class  Time
 
class  TimeMetric
 
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
 
struct  union_entry_t
 
struct  UnionType
 
class  UnionVector
 
struct  UniqLock
 
struct  UUID
 
class  Value
 
class  ValueVector
 
class  Writer
 

Concepts

concept  IntegerTypes
 
concept  NumericTypes
 
concept  ComparableTypes
 
concept  HashablePrimitive
 
concept  IndexHashable
 
concept  HashableNonNestedTypes
 
concept  HashableNestedTypes
 
concept  HashableTypes
 

Typedefs

template<typename T >
using case_insensitive_map_t
 
using table_id_t = uint64_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
 
typedef std::unique_ptr< ProgressBarDisplay >(* progress_bar_display_create_func_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 property_id_t = uint32_t
 
using column_id_t = property_id_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 transaction_t = uint64_t
 
using executor_id_t = uint64_t
 
using executor_info = std::unordered_map<executor_id_t, uint64_t>
 
using logical_type_vec_t = std::vector<LogicalType>
 

Enumerations

enum class  AlterType : uint8_t {
  RENAME_TABLE = 0 , ADD_PROPERTY = 10 , DROP_PROPERTY = 11 , RENAME_PROPERTY = 12 ,
  COMMENT = 201
}
 
enum class  ConflictAction : uint8_t { ON_CONFLICT_THROW = 0 , ON_CONFLICT_DO_NOTHING = 1 }
 
enum  PageSizeClass : uint8_t { PAGE_4KB = 0 , PAGE_256KB = 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
}
 
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  RelMultiplicity : uint8_t { MANY , ONE }
 
enum class  StatementType : uint8_t {
  QUERY = 0 , CREATE_TABLE = 1 , DROP = 2 , ALTER = 3 ,
  COPY_TO = 19 , COPY_FROM = 20 , STANDALONE_CALL = 21 , EXPLAIN = 22 ,
  CREATE_MACRO = 23 , 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  TableType : uint8_t {
  UNKNOWN = 0 , NODE = 1 , REL = 2 , RDF = 3 ,
  REL_GROUP = 4 , FOREIGN = 5
}
 
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 , RDF_VARIANT = 57 , 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 , STRING = 20 ,
  LIST = 22 , ARRAY = 23 , STRUCT = 24 , POINTER = 25
}
 
enum class  FileVersionType : uint8_t { ORIGINAL = 0 , WAL_VERSION = 1 }
 
enum class  ZoneMapCheckResult : uint8_t { ALWAYS_SCAN = 0 , SKIP_SCAN = 1 }
 

Functions

void kuAssertFailureInternal (const char *condition_name, const char *file, int linenr)
 
template<typename FROM , typename TO >
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<>
KUZU_API std::string RdfVariant::getValue< std::string > (const Value *rdfVariant)
 Specialization for string.
 
template<typename... Args>
std::string stringFormat (std::string_view format, Args... args)
 

Variables

const char * KUZU_VERSION
 
constexpr uint64_t DEFAULT_VECTOR_CAPACITY_LOG_2 = 11
 
constexpr uint64_t DEFAULT_VECTOR_CAPACITY
 
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
 
constexpr table_id_t INVALID_TABLE_ID = UINT64_MAX
 
constexpr offset_t INVALID_OFFSET = UINT64_MAX
 
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 page_idx_t INVALID_PAGE_IDX = UINT32_MAX
 
constexpr file_idx_t INVALID_FILE_IDX = UINT32_MAX
 
constexpr property_id_t INVALID_PROPERTY_ID = UINT32_MAX
 
constexpr column_id_t INVALID_COLUMN_ID = INVALID_PROPERTY_ID
 
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 transaction_t INVALID_TRANSACTION = UINT64_MAX
 

Typedef Documentation

◆ block_idx_t

using kuzu::common::block_idx_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>

◆ column_id_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

◆ 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

◆ progress_bar_display_create_func_t

typedef std::unique_ptr< ProgressBarDisplay >(* kuzu::common::progress_bar_display_create_func_t) ()

◆ property_id_t

using kuzu::common::property_id_t = uint32_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

using kuzu::common::table_id_t = uint64_t

◆ table_id_vector_t

◆ transaction_t

using kuzu::common::transaction_t = uint64_t

◆ union_field_idx_t

Enumeration Type Documentation

◆ AlterType

enum class kuzu::common::AlterType : uint8_t
strong
Enumerator
RENAME_TABLE 
ADD_PROPERTY 
DROP_PROPERTY 
RENAME_PROPERTY 
COMMENT 

◆ ConflictAction

enum class kuzu::common::ConflictAction : uint8_t
strong
Enumerator
ON_CONFLICT_THROW 
ON_CONFLICT_DO_NOTHING 

◆ 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 

◆ 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 
RDF_VARIANT 
POINTER 
UUID 

◆ PageSizeClass

Enumerator
PAGE_4KB 
PAGE_256KB 

◆ 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 
STRING 
LIST 
ARRAY 
STRUCT 
POINTER 

◆ RelMultiplicity

enum class kuzu::common::RelMultiplicity : uint8_t
strong
Enumerator
MANY 
ONE 

◆ StatementType

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

◆ TableType

enum class kuzu::common::TableType : uint8_t
strong
Enumerator
UNKNOWN 
NODE 
REL 
RDF 
REL_GROUP 
FOREIGN 

◆ ZoneMapCheckResult

enum class kuzu::common::ZoneMapCheckResult : uint8_t
strong
Enumerator
ALWAYS_SCAN 
SKIP_SCAN 

Function Documentation

◆ ku_dynamic_cast()

template<typename FROM , typename TO >
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)

◆ RdfVariant::getValue< std::string >()

template<>
KUZU_API std::string kuzu::common::RdfVariant::getValue< std::string > ( const Value * rdfVariant)
inline

Specialization for string.

Parameters
rdfVariantthe rdf variant.
Returns
the string value.

◆ 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
constexpr
Initial value:
= static_cast<uint64_t>(1)
<< DEFAULT_VECTOR_CAPACITY_LOG_2

◆ DEFAULT_VECTOR_CAPACITY_LOG_2

uint64_t kuzu::common::DEFAULT_VECTOR_CAPACITY_LOG_2 = 11
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 = INVALID_PROPERTY_ID
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_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_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_PROPERTY_ID

property_id_t kuzu::common::INVALID_PROPERTY_ID = UINT32_MAX
constexpr

◆ INVALID_ROW_IDX

row_idx_t kuzu::common::INVALID_ROW_IDX = 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 = UINT64_MAX
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