lbug 0.16.1

An in-process property graph database management system built for query speed and scalability
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#pragma once

// The Arrow C data interface.
// https://arrow.apache.org/docs/format/CDataInterface.html

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef ARROW_C_DATA_INTERFACE
#define ARROW_C_DATA_INTERFACE

#define ARROW_FLAG_DICTIONARY_ORDERED 1
#define ARROW_FLAG_NULLABLE 2
#define ARROW_FLAG_MAP_KEYS_SORTED 4

struct ArrowSchema {
    // Array type description
    const char* format;
    const char* name;
    const char* metadata;
    int64_t flags;
    int64_t n_children;
    struct ArrowSchema** children;
    struct ArrowSchema* dictionary;

    // Release callback
    void (*release)(struct ArrowSchema*);
    // Opaque producer-specific data
    void* private_data;
};

struct ArrowArray {
    // Array data description
    int64_t length;
    int64_t null_count;
    int64_t offset;
    int64_t n_buffers;
    int64_t n_children;
    const void** buffers;
    struct ArrowArray** children;
    struct ArrowArray* dictionary;

    // Release callback
    void (*release)(struct ArrowArray*);
    // Opaque producer-specific data
    void* private_data;
};

#endif // ARROW_C_DATA_INTERFACE

#ifdef __cplusplus
}
#endif

struct ArrowSchemaWrapper : public ArrowSchema {
    ArrowSchemaWrapper() : ArrowSchema{} { release = nullptr; }
    ~ArrowSchemaWrapper() {
        if (release) {
            release(this);
        }
    }

    // Move constructor
    ArrowSchemaWrapper(ArrowSchemaWrapper&& other) noexcept : ArrowSchema(other) {
        other.release = nullptr;
    }

    // Move assignment
    ArrowSchemaWrapper& operator=(ArrowSchemaWrapper&& other) noexcept {
        if (this != &other) {
            if (release) {
                release(this);
            }
            ArrowSchema::operator=(other);
            other.release = nullptr;
        }
        return *this;
    }

    // Delete copy constructor and copy assignment
    ArrowSchemaWrapper(const ArrowSchemaWrapper&) = delete;
    ArrowSchemaWrapper& operator=(const ArrowSchemaWrapper&) = delete;
};

struct ArrowArrayWrapper : public ArrowArray {
    ArrowArrayWrapper() : ArrowArray{} { release = nullptr; }
    ~ArrowArrayWrapper() {
        if (release) {
            release(this);
        }
    }

    // Move constructor
    ArrowArrayWrapper(ArrowArrayWrapper&& other) noexcept : ArrowArray(other) {
        other.release = nullptr;
    }

    // Move assignment
    ArrowArrayWrapper& operator=(ArrowArrayWrapper&& other) noexcept {
        if (this != &other) {
            if (release) {
                release(this);
            }
            ArrowArray::operator=(other);
            other.release = nullptr;
        }
        return *this;
    }

    // Delete copy constructor and copy assignment
    ArrowArrayWrapper(const ArrowArrayWrapper&) = delete;
    ArrowArrayWrapper& operator=(const ArrowArrayWrapper&) = delete;
};

// Helper functions for creating shallow copies of Arrow wrappers
// These create copies that reference existing data without taking ownership
inline ArrowSchemaWrapper createShallowCopy(const ArrowSchemaWrapper& original) {
    ArrowSchemaWrapper copy;
    copy.format = original.format;
    copy.name = original.name;
    copy.metadata = original.metadata;
    copy.flags = original.flags;
    copy.n_children = original.n_children;
    copy.children = original.children;
    copy.dictionary = original.dictionary;
    copy.release = nullptr; // Don't release - original owns it
    copy.private_data = original.private_data;
    return copy;
}

inline ArrowArrayWrapper createShallowCopy(const ArrowArrayWrapper& original) {
    ArrowArrayWrapper copy;
    copy.length = original.length;
    copy.null_count = original.null_count;
    copy.offset = original.offset;
    copy.n_buffers = original.n_buffers;
    copy.n_children = original.n_children;
    copy.buffers = original.buffers;
    copy.children = original.children;
    copy.dictionary = original.dictionary;
    copy.release = nullptr; // Don't release - original owns it
    copy.private_data = original.private_data;
    return copy;
}