blob: 54edc2b6696dc48c0345c8097b25245c21d67099 (
plain)
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
// file : libbrep/build-package.hxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#ifndef LIBBREP_BUILD_PACKAGE_HXX
#define LIBBREP_BUILD_PACKAGE_HXX
#include <odb/core.hxx>
#include <odb/nested-container.hxx>
#include <libbrep/types.hxx>
#include <libbrep/utility.hxx>
#include <libbrep/common.hxx> // Must be included last (see assert).
namespace brep
{
// These are "foreign objects" that are mapped to subsets of the package
// database objects using the PostgreSQL foreign table mechanism. Note that
// since we maintain the pair in sync by hand, we should only have a minimal
// subset of "core" members (ideally just the primary key) that are unlikly
// to disappear or change.
//
// The mapping is established in build-extra.sql. We also explicitly mark
// non-primary key foreign-mapped members in the source object.
//
// Foreign object that is mapped to a subset of the tenant object.
//
#pragma db object table("build_tenant") pointer(shared_ptr) readonly
class build_tenant
{
public:
string id;
bool private_;
optional<string> interactive;
bool archived;
// Database mapping.
//
#pragma db member(id) id
private:
friend class odb::access;
build_tenant () = default;
};
// Foreign object that is mapped to a subset of the repository object.
//
#pragma db object table("build_repository") pointer(shared_ptr) readonly
class build_repository
{
public:
repository_id id;
const string& canonical_name; // Tracks id.canonical_name.
repository_location location;
optional<string> certificate_fingerprint;
// Database mapping.
//
#pragma db member(id) id column("")
#pragma db member(canonical_name) transient
#pragma db member(location) \
set(this.location = std::move (?); \
assert (this.canonical_name == this.location.canonical_name ()))
private:
friend class odb::access;
build_repository (): canonical_name (id.canonical_name) {}
};
// Forward declarations.
//
class build_package;
// Build package dependency.
//
#pragma db value
struct build_dependency
{
package_name name;
optional<version_constraint> constraint;
lazy_shared_ptr<build_package> package;
// Database mapping.
//
#pragma db member(constraint) column("")
};
// Build package external test dependency.
//
#pragma db value
struct build_test_dependency: build_dependency
{
test_dependency_type type;
bool buildtime;
optional<string> reflect;
};
// Foreign object that is mapped to a subset of the package object.
//
#pragma db object table("build_package") pointer(shared_ptr) readonly session
class build_package
{
public:
using requirements_type = brep::requirements;
package_id id;
upstream_version version;
// Mapped to the package object requirements and tests members using the
// PostgreSQL foreign table mechanism.
//
requirements_type requirements;
small_vector<build_test_dependency, 1> tests;
lazy_shared_ptr<build_repository> internal_repository;
bool buildable;
// Mapped to the package object builds and build_constraints members using
// the PostgreSQL foreign table mechanism.
//
build_class_exprs builds;
build_constraints constraints;
bool
internal () const noexcept {return internal_repository != nullptr;}
// Database mapping.
//
#pragma db member(id) id column("")
#pragma db member(version) set(this.version.init (this.id.version, (?)))
// requirements
//
// Note that this is a 2-level nested container (see package.hxx for
// details).
//
// Container of the requirement_alternatives values.
//
#pragma db member(requirements) id_column("") value_column("")
// Container of the requirement_alternative values.
//
#pragma db member(requirement_alternative_key::outer) column("requirement_index")
#pragma db member(requirement_alternative_key::inner) column("index")
#pragma db member(requirement_alternatives) \
virtual(requirement_alternatives_map) \
after(requirements) \
get(odb::nested_get (this.requirements)) \
set(odb::nested_set (this.requirements, std::move (?))) \
id_column("") key_column("") value_column("")
// Container of the requirement (string) values.
//
#pragma db member(requirement_key::outer) column("requirement_index")
#pragma db member(requirement_key::middle) column("alternative_index")
#pragma db member(requirement_key::inner) column("index")
#pragma db member(requirement_alternative_requirements) \
virtual(requirement_alternative_requirements_map) \
after(requirement_alternatives) \
get(odb::nested2_get (this.requirements)) \
set(odb::nested2_set (this.requirements, std::move (?))) \
id_column("") key_column("") value_column("id")
// tests, builds, and constraints
//
#pragma db member(tests) id_column("") value_column("test_")
#pragma db member(builds) id_column("") value_column("")
#pragma db member(constraints) id_column("") value_column("")
private:
friend class odb::access;
build_package () = default;
};
// Packages that can potentially be built.
//
// Note that ADL can't find the equal operator, so we use the function call
// notation.
//
#pragma db view \
object(build_package) \
object(build_repository inner: \
build_package::buildable && \
brep::operator== (build_package::internal_repository, \
build_repository::id)) \
object(build_tenant: build_package::id.tenant == build_tenant::id)
struct buildable_package
{
package_id id;
upstream_version version;
bool archived; // True if the tenant the package belongs to is archived.
// Database mapping.
//
#pragma db member(version) set(this.version.init (this.id.version, (?)))
};
#pragma db view \
object(build_package) \
object(build_repository inner: \
build_package::buildable && \
brep::operator== (build_package::internal_repository, \
build_repository::id)) \
object(build_tenant: build_package::id.tenant == build_tenant::id)
struct buildable_package_count
{
size_t result;
operator size_t () const {return result;}
// Database mapping.
//
#pragma db member(result) column("count(" + build_package::id.name + ")")
};
}
#endif // LIBBREP_BUILD_PACKAGE_HXX
|
