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
|
#pragma once
#include <string>
#include <vector>
/**
* @file Types.h
* @brief Shared enum types and core data types used by the runtime.
*/
/** @brief Runtime object categories known by the object manager. */
enum OBJECT_TYPE {
/** A database snapshot grouping relations and tuples. */
MULTIGROUP,
/** A relation object backed by physical storage. */
RELATION,
/** An attribute object (schema metadata). */
ATTRIBUTE,
/** A transaction object. */
TRANSACTION,
/**
* A relation whose tuples are produced on demand by a generator function
* rather than read from physical storage. Cardinality may be finite (e.g.
* a projected stored relation) or AlephZero (e.g. the eq builtin). The
* object_type for this label must be an ephemeral_object_type.
*/
EPHEMERAL_RELATION,
/**
* A named mutable reference to a multigroup state, analogous to a git
* branch. A BRANCH object carries an opaque payload (serialized multigroup
* bytes) that the caller — in practice Sakura — deserializes on open.
*
* Branch objects are the entry point for database connections: a client
* opens a handle to /system/branches/<name>, reads the payload bytes to
* reconstruct the multigroup in memory, and holds the handle for the
* duration of the session.
*
* The `exclusive` flag on the object_type should be set to true so that
* LifecycleManager::Contention serializes concurrent writers.
*/
BRANCH,
/**
* A named query plan stored in the object registry. A VIEW object carries
* the serialized plan definition and the multigroup hash at definition time.
* No handles to physical storage are kept open in the VIEW object itself.
* Each time the view is opened, fresh relation handles and cursors are
* created for the duration of that execution, then released on close.
*
* @todo Implement ObjectManager::View, rnt_register_view, and the
* open-view path in HandlerManager. Views are reserved in the type
* system but have no runtime support yet.
*/
VIEW
};
/** @brief Operations that may be supported by an object type. */
enum METHOD {
/** Opens an object and creates an authorized handle. */
OPEN,
/** Closes a previously opened handle. */
CLOSE,
/** Parses through a secondary namespace. */
PARSE,
/** Performs security checks. */
SECURITY
};
/** @brief Claims granted to an authenticated connection. */
enum AUTH_CLAIM {
/** Permission to read object state. */
READ,
/** Permission to mutate object state. */
WRITE
};
/** @brief Authentication strategies supported by the permissions layer. */
enum AUTH_METHOD {
/** Certificate-based authentication. */
CERTIFICATE,
/** Plain-text authentication. */
PLAIN_TEXT
};
namespace nt
{
/** @brief A single named value in a tuple, produced by the cursor layer. */
struct Attribute {
std::string name;
std::string value;
};
/**
* @brief A single row of data streamed lazily from the cursor layer.
*
* Follows the Volcano pull model: callers repeatedly call Next() to consume
* one attribute at a time. Returns nullptr when all attributes are exhausted.
*/
class Tuple {
public:
explicit Tuple(std::vector<Attribute> attributes)
: attributes_(std::move(attributes)) {}
/** @brief Returns the next attribute, or nullptr when exhausted. */
const Attribute* Next() {
if (position_ < attributes_.size())
return &attributes_[position_++];
return nullptr;
}
void Reset() { position_ = 0; }
/** @brief Direct read-only access to all attributes without affecting position. */
const std::vector<Attribute>& attrs() const { return attributes_; }
private:
std::vector<Attribute> attributes_;
size_t position_ = 0;
};
}
|
