]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | // automatically generated by the FlatBuffers compiler, do not modify |
2 | ||
3 | ||
4 | #ifndef FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ | |
5 | #define FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ | |
6 | ||
7 | #include "flatbuffers/flatbuffers.h" | |
8 | ||
9 | #include "Schema_generated.h" | |
10 | #include "Expression_generated.h" | |
11 | #include "Literal_generated.h" | |
12 | ||
13 | namespace org { | |
14 | namespace apache { | |
15 | namespace arrow { | |
16 | namespace computeir { | |
17 | namespace flatbuf { | |
18 | ||
19 | struct Remap; | |
20 | struct RemapBuilder; | |
21 | ||
22 | struct PassThrough; | |
23 | struct PassThroughBuilder; | |
24 | ||
25 | struct RelId; | |
26 | struct RelIdBuilder; | |
27 | ||
28 | struct RelBase; | |
29 | struct RelBaseBuilder; | |
30 | ||
31 | struct Filter; | |
32 | struct FilterBuilder; | |
33 | ||
34 | struct Project; | |
35 | struct ProjectBuilder; | |
36 | ||
37 | struct Grouping; | |
38 | struct GroupingBuilder; | |
39 | ||
40 | struct Aggregate; | |
41 | struct AggregateBuilder; | |
42 | ||
43 | struct Join; | |
44 | struct JoinBuilder; | |
45 | ||
46 | struct OrderBy; | |
47 | struct OrderByBuilder; | |
48 | ||
49 | struct Limit; | |
50 | struct LimitBuilder; | |
51 | ||
52 | struct SetOperation; | |
53 | struct SetOperationBuilder; | |
54 | ||
55 | struct LiteralColumn; | |
56 | struct LiteralColumnBuilder; | |
57 | ||
58 | struct LiteralRelation; | |
59 | struct LiteralRelationBuilder; | |
60 | ||
61 | struct Source; | |
62 | struct SourceBuilder; | |
63 | ||
64 | struct Relation; | |
65 | struct RelationBuilder; | |
66 | ||
67 | /// A union for the different colum remapping variants | |
68 | enum class Emit : uint8_t { | |
69 | NONE = 0, | |
70 | Remap = 1, | |
71 | PassThrough = 2, | |
72 | MIN = NONE, | |
73 | MAX = PassThrough | |
74 | }; | |
75 | ||
76 | inline const Emit (&EnumValuesEmit())[3] { | |
77 | static const Emit values[] = { | |
78 | Emit::NONE, | |
79 | Emit::Remap, | |
80 | Emit::PassThrough | |
81 | }; | |
82 | return values; | |
83 | } | |
84 | ||
85 | inline const char * const *EnumNamesEmit() { | |
86 | static const char * const names[4] = { | |
87 | "NONE", | |
88 | "Remap", | |
89 | "PassThrough", | |
90 | nullptr | |
91 | }; | |
92 | return names; | |
93 | } | |
94 | ||
95 | inline const char *EnumNameEmit(Emit e) { | |
96 | if (flatbuffers::IsOutRange(e, Emit::NONE, Emit::PassThrough)) return ""; | |
97 | const size_t index = static_cast<size_t>(e); | |
98 | return EnumNamesEmit()[index]; | |
99 | } | |
100 | ||
101 | template<typename T> struct EmitTraits { | |
102 | static const Emit enum_value = Emit::NONE; | |
103 | }; | |
104 | ||
105 | template<> struct EmitTraits<org::apache::arrow::computeir::flatbuf::Remap> { | |
106 | static const Emit enum_value = Emit::Remap; | |
107 | }; | |
108 | ||
109 | template<> struct EmitTraits<org::apache::arrow::computeir::flatbuf::PassThrough> { | |
110 | static const Emit enum_value = Emit::PassThrough; | |
111 | }; | |
112 | ||
113 | bool VerifyEmit(flatbuffers::Verifier &verifier, const void *obj, Emit type); | |
114 | bool VerifyEmitVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); | |
115 | ||
116 | enum class JoinKind : uint8_t { | |
117 | Anti = 0, | |
118 | Cross = 1, | |
119 | FullOuter = 2, | |
120 | Inner = 3, | |
121 | LeftOuter = 4, | |
122 | LeftSemi = 5, | |
123 | RightOuter = 6, | |
124 | MIN = Anti, | |
125 | MAX = RightOuter | |
126 | }; | |
127 | ||
128 | inline const JoinKind (&EnumValuesJoinKind())[7] { | |
129 | static const JoinKind values[] = { | |
130 | JoinKind::Anti, | |
131 | JoinKind::Cross, | |
132 | JoinKind::FullOuter, | |
133 | JoinKind::Inner, | |
134 | JoinKind::LeftOuter, | |
135 | JoinKind::LeftSemi, | |
136 | JoinKind::RightOuter | |
137 | }; | |
138 | return values; | |
139 | } | |
140 | ||
141 | inline const char * const *EnumNamesJoinKind() { | |
142 | static const char * const names[8] = { | |
143 | "Anti", | |
144 | "Cross", | |
145 | "FullOuter", | |
146 | "Inner", | |
147 | "LeftOuter", | |
148 | "LeftSemi", | |
149 | "RightOuter", | |
150 | nullptr | |
151 | }; | |
152 | return names; | |
153 | } | |
154 | ||
155 | inline const char *EnumNameJoinKind(JoinKind e) { | |
156 | if (flatbuffers::IsOutRange(e, JoinKind::Anti, JoinKind::RightOuter)) return ""; | |
157 | const size_t index = static_cast<size_t>(e); | |
158 | return EnumNamesJoinKind()[index]; | |
159 | } | |
160 | ||
161 | /// The kind of set operation being performed. | |
162 | enum class SetOpKind : uint8_t { | |
163 | Union = 0, | |
164 | Intersection = 1, | |
165 | Difference = 2, | |
166 | MIN = Union, | |
167 | MAX = Difference | |
168 | }; | |
169 | ||
170 | inline const SetOpKind (&EnumValuesSetOpKind())[3] { | |
171 | static const SetOpKind values[] = { | |
172 | SetOpKind::Union, | |
173 | SetOpKind::Intersection, | |
174 | SetOpKind::Difference | |
175 | }; | |
176 | return values; | |
177 | } | |
178 | ||
179 | inline const char * const *EnumNamesSetOpKind() { | |
180 | static const char * const names[4] = { | |
181 | "Union", | |
182 | "Intersection", | |
183 | "Difference", | |
184 | nullptr | |
185 | }; | |
186 | return names; | |
187 | } | |
188 | ||
189 | inline const char *EnumNameSetOpKind(SetOpKind e) { | |
190 | if (flatbuffers::IsOutRange(e, SetOpKind::Union, SetOpKind::Difference)) return ""; | |
191 | const size_t index = static_cast<size_t>(e); | |
192 | return EnumNamesSetOpKind()[index]; | |
193 | } | |
194 | ||
195 | /// The varieties of relations | |
196 | enum class RelationImpl : uint8_t { | |
197 | NONE = 0, | |
198 | Aggregate = 1, | |
199 | Filter = 2, | |
200 | Join = 3, | |
201 | Limit = 4, | |
202 | LiteralRelation = 5, | |
203 | OrderBy = 6, | |
204 | Project = 7, | |
205 | SetOperation = 8, | |
206 | Source = 9, | |
207 | MIN = NONE, | |
208 | MAX = Source | |
209 | }; | |
210 | ||
211 | inline const RelationImpl (&EnumValuesRelationImpl())[10] { | |
212 | static const RelationImpl values[] = { | |
213 | RelationImpl::NONE, | |
214 | RelationImpl::Aggregate, | |
215 | RelationImpl::Filter, | |
216 | RelationImpl::Join, | |
217 | RelationImpl::Limit, | |
218 | RelationImpl::LiteralRelation, | |
219 | RelationImpl::OrderBy, | |
220 | RelationImpl::Project, | |
221 | RelationImpl::SetOperation, | |
222 | RelationImpl::Source | |
223 | }; | |
224 | return values; | |
225 | } | |
226 | ||
227 | inline const char * const *EnumNamesRelationImpl() { | |
228 | static const char * const names[11] = { | |
229 | "NONE", | |
230 | "Aggregate", | |
231 | "Filter", | |
232 | "Join", | |
233 | "Limit", | |
234 | "LiteralRelation", | |
235 | "OrderBy", | |
236 | "Project", | |
237 | "SetOperation", | |
238 | "Source", | |
239 | nullptr | |
240 | }; | |
241 | return names; | |
242 | } | |
243 | ||
244 | inline const char *EnumNameRelationImpl(RelationImpl e) { | |
245 | if (flatbuffers::IsOutRange(e, RelationImpl::NONE, RelationImpl::Source)) return ""; | |
246 | const size_t index = static_cast<size_t>(e); | |
247 | return EnumNamesRelationImpl()[index]; | |
248 | } | |
249 | ||
250 | template<typename T> struct RelationImplTraits { | |
251 | static const RelationImpl enum_value = RelationImpl::NONE; | |
252 | }; | |
253 | ||
254 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Aggregate> { | |
255 | static const RelationImpl enum_value = RelationImpl::Aggregate; | |
256 | }; | |
257 | ||
258 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Filter> { | |
259 | static const RelationImpl enum_value = RelationImpl::Filter; | |
260 | }; | |
261 | ||
262 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Join> { | |
263 | static const RelationImpl enum_value = RelationImpl::Join; | |
264 | }; | |
265 | ||
266 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Limit> { | |
267 | static const RelationImpl enum_value = RelationImpl::Limit; | |
268 | }; | |
269 | ||
270 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::LiteralRelation> { | |
271 | static const RelationImpl enum_value = RelationImpl::LiteralRelation; | |
272 | }; | |
273 | ||
274 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::OrderBy> { | |
275 | static const RelationImpl enum_value = RelationImpl::OrderBy; | |
276 | }; | |
277 | ||
278 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Project> { | |
279 | static const RelationImpl enum_value = RelationImpl::Project; | |
280 | }; | |
281 | ||
282 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::SetOperation> { | |
283 | static const RelationImpl enum_value = RelationImpl::SetOperation; | |
284 | }; | |
285 | ||
286 | template<> struct RelationImplTraits<org::apache::arrow::computeir::flatbuf::Source> { | |
287 | static const RelationImpl enum_value = RelationImpl::Source; | |
288 | }; | |
289 | ||
290 | bool VerifyRelationImpl(flatbuffers::Verifier &verifier, const void *obj, RelationImpl type); | |
291 | bool VerifyRelationImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); | |
292 | ||
293 | /// A data type indicating that a different mapping of columns | |
294 | /// should occur in the output. | |
295 | /// | |
296 | /// For example: | |
297 | /// | |
298 | /// Given a query `SELECT b, a FROM t` where `t` has columns a, b, c | |
299 | /// the mapping value for the projection would equal [1, 0]. | |
300 | struct Remap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
301 | typedef RemapBuilder Builder; | |
302 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
303 | VT_MAPPING = 4 | |
304 | }; | |
305 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>> *mapping() const { | |
306 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>> *>(VT_MAPPING); | |
307 | } | |
308 | bool Verify(flatbuffers::Verifier &verifier) const { | |
309 | return VerifyTableStart(verifier) && | |
310 | VerifyOffsetRequired(verifier, VT_MAPPING) && | |
311 | verifier.VerifyVector(mapping()) && | |
312 | verifier.VerifyVectorOfTables(mapping()) && | |
313 | verifier.EndTable(); | |
314 | } | |
315 | }; | |
316 | ||
317 | struct RemapBuilder { | |
318 | typedef Remap Table; | |
319 | flatbuffers::FlatBufferBuilder &fbb_; | |
320 | flatbuffers::uoffset_t start_; | |
321 | void add_mapping(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>>> mapping) { | |
322 | fbb_.AddOffset(Remap::VT_MAPPING, mapping); | |
323 | } | |
324 | explicit RemapBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
325 | : fbb_(_fbb) { | |
326 | start_ = fbb_.StartTable(); | |
327 | } | |
328 | RemapBuilder &operator=(const RemapBuilder &); | |
329 | flatbuffers::Offset<Remap> Finish() { | |
330 | const auto end = fbb_.EndTable(start_); | |
331 | auto o = flatbuffers::Offset<Remap>(end); | |
332 | fbb_.Required(o, Remap::VT_MAPPING); | |
333 | return o; | |
334 | } | |
335 | }; | |
336 | ||
337 | inline flatbuffers::Offset<Remap> CreateRemap( | |
338 | flatbuffers::FlatBufferBuilder &_fbb, | |
339 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>>> mapping = 0) { | |
340 | RemapBuilder builder_(_fbb); | |
341 | builder_.add_mapping(mapping); | |
342 | return builder_.Finish(); | |
343 | } | |
344 | ||
345 | inline flatbuffers::Offset<Remap> CreateRemapDirect( | |
346 | flatbuffers::FlatBufferBuilder &_fbb, | |
347 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>> *mapping = nullptr) { | |
348 | auto mapping__ = mapping ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::FieldIndex>>(*mapping) : 0; | |
349 | return org::apache::arrow::computeir::flatbuf::CreateRemap( | |
350 | _fbb, | |
351 | mapping__); | |
352 | } | |
353 | ||
354 | struct PassThrough FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
355 | typedef PassThroughBuilder Builder; | |
356 | bool Verify(flatbuffers::Verifier &verifier) const { | |
357 | return VerifyTableStart(verifier) && | |
358 | verifier.EndTable(); | |
359 | } | |
360 | }; | |
361 | ||
362 | struct PassThroughBuilder { | |
363 | typedef PassThrough Table; | |
364 | flatbuffers::FlatBufferBuilder &fbb_; | |
365 | flatbuffers::uoffset_t start_; | |
366 | explicit PassThroughBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
367 | : fbb_(_fbb) { | |
368 | start_ = fbb_.StartTable(); | |
369 | } | |
370 | PassThroughBuilder &operator=(const PassThroughBuilder &); | |
371 | flatbuffers::Offset<PassThrough> Finish() { | |
372 | const auto end = fbb_.EndTable(start_); | |
373 | auto o = flatbuffers::Offset<PassThrough>(end); | |
374 | return o; | |
375 | } | |
376 | }; | |
377 | ||
378 | inline flatbuffers::Offset<PassThrough> CreatePassThrough( | |
379 | flatbuffers::FlatBufferBuilder &_fbb) { | |
380 | PassThroughBuilder builder_(_fbb); | |
381 | return builder_.Finish(); | |
382 | } | |
383 | ||
384 | /// An identifier for relations in a query. | |
385 | /// | |
386 | /// A table is used here to allow plan implementations optionality. | |
387 | struct RelId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
388 | typedef RelIdBuilder Builder; | |
389 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
390 | VT_ID = 4 | |
391 | }; | |
392 | uint64_t id() const { | |
393 | return GetField<uint64_t>(VT_ID, 0); | |
394 | } | |
395 | bool Verify(flatbuffers::Verifier &verifier) const { | |
396 | return VerifyTableStart(verifier) && | |
397 | VerifyField<uint64_t>(verifier, VT_ID) && | |
398 | verifier.EndTable(); | |
399 | } | |
400 | }; | |
401 | ||
402 | struct RelIdBuilder { | |
403 | typedef RelId Table; | |
404 | flatbuffers::FlatBufferBuilder &fbb_; | |
405 | flatbuffers::uoffset_t start_; | |
406 | void add_id(uint64_t id) { | |
407 | fbb_.AddElement<uint64_t>(RelId::VT_ID, id, 0); | |
408 | } | |
409 | explicit RelIdBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
410 | : fbb_(_fbb) { | |
411 | start_ = fbb_.StartTable(); | |
412 | } | |
413 | RelIdBuilder &operator=(const RelIdBuilder &); | |
414 | flatbuffers::Offset<RelId> Finish() { | |
415 | const auto end = fbb_.EndTable(start_); | |
416 | auto o = flatbuffers::Offset<RelId>(end); | |
417 | return o; | |
418 | } | |
419 | }; | |
420 | ||
421 | inline flatbuffers::Offset<RelId> CreateRelId( | |
422 | flatbuffers::FlatBufferBuilder &_fbb, | |
423 | uint64_t id = 0) { | |
424 | RelIdBuilder builder_(_fbb); | |
425 | builder_.add_id(id); | |
426 | return builder_.Finish(); | |
427 | } | |
428 | ||
429 | /// Fields common to every relational operator | |
430 | struct RelBase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
431 | typedef RelBaseBuilder Builder; | |
432 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
433 | VT_OUTPUT_MAPPING_TYPE = 4, | |
434 | VT_OUTPUT_MAPPING = 6, | |
435 | VT_ID = 8 | |
436 | }; | |
437 | org::apache::arrow::computeir::flatbuf::Emit output_mapping_type() const { | |
438 | return static_cast<org::apache::arrow::computeir::flatbuf::Emit>(GetField<uint8_t>(VT_OUTPUT_MAPPING_TYPE, 0)); | |
439 | } | |
440 | /// Output remapping of ordinal columns for a given operation | |
441 | const void *output_mapping() const { | |
442 | return GetPointer<const void *>(VT_OUTPUT_MAPPING); | |
443 | } | |
444 | template<typename T> const T *output_mapping_as() const; | |
445 | const org::apache::arrow::computeir::flatbuf::Remap *output_mapping_as_Remap() const { | |
446 | return output_mapping_type() == org::apache::arrow::computeir::flatbuf::Emit::Remap ? static_cast<const org::apache::arrow::computeir::flatbuf::Remap *>(output_mapping()) : nullptr; | |
447 | } | |
448 | const org::apache::arrow::computeir::flatbuf::PassThrough *output_mapping_as_PassThrough() const { | |
449 | return output_mapping_type() == org::apache::arrow::computeir::flatbuf::Emit::PassThrough ? static_cast<const org::apache::arrow::computeir::flatbuf::PassThrough *>(output_mapping()) : nullptr; | |
450 | } | |
451 | /// An identifiier for a relation. The identifier should be unique over the | |
452 | /// entire plan. Optional. | |
453 | const org::apache::arrow::computeir::flatbuf::RelId *id() const { | |
454 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelId *>(VT_ID); | |
455 | } | |
456 | bool Verify(flatbuffers::Verifier &verifier) const { | |
457 | return VerifyTableStart(verifier) && | |
458 | VerifyField<uint8_t>(verifier, VT_OUTPUT_MAPPING_TYPE) && | |
459 | VerifyOffsetRequired(verifier, VT_OUTPUT_MAPPING) && | |
460 | VerifyEmit(verifier, output_mapping(), output_mapping_type()) && | |
461 | VerifyOffset(verifier, VT_ID) && | |
462 | verifier.VerifyTable(id()) && | |
463 | verifier.EndTable(); | |
464 | } | |
465 | }; | |
466 | ||
467 | template<> inline const org::apache::arrow::computeir::flatbuf::Remap *RelBase::output_mapping_as<org::apache::arrow::computeir::flatbuf::Remap>() const { | |
468 | return output_mapping_as_Remap(); | |
469 | } | |
470 | ||
471 | template<> inline const org::apache::arrow::computeir::flatbuf::PassThrough *RelBase::output_mapping_as<org::apache::arrow::computeir::flatbuf::PassThrough>() const { | |
472 | return output_mapping_as_PassThrough(); | |
473 | } | |
474 | ||
475 | struct RelBaseBuilder { | |
476 | typedef RelBase Table; | |
477 | flatbuffers::FlatBufferBuilder &fbb_; | |
478 | flatbuffers::uoffset_t start_; | |
479 | void add_output_mapping_type(org::apache::arrow::computeir::flatbuf::Emit output_mapping_type) { | |
480 | fbb_.AddElement<uint8_t>(RelBase::VT_OUTPUT_MAPPING_TYPE, static_cast<uint8_t>(output_mapping_type), 0); | |
481 | } | |
482 | void add_output_mapping(flatbuffers::Offset<void> output_mapping) { | |
483 | fbb_.AddOffset(RelBase::VT_OUTPUT_MAPPING, output_mapping); | |
484 | } | |
485 | void add_id(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelId> id) { | |
486 | fbb_.AddOffset(RelBase::VT_ID, id); | |
487 | } | |
488 | explicit RelBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
489 | : fbb_(_fbb) { | |
490 | start_ = fbb_.StartTable(); | |
491 | } | |
492 | RelBaseBuilder &operator=(const RelBaseBuilder &); | |
493 | flatbuffers::Offset<RelBase> Finish() { | |
494 | const auto end = fbb_.EndTable(start_); | |
495 | auto o = flatbuffers::Offset<RelBase>(end); | |
496 | fbb_.Required(o, RelBase::VT_OUTPUT_MAPPING); | |
497 | return o; | |
498 | } | |
499 | }; | |
500 | ||
501 | inline flatbuffers::Offset<RelBase> CreateRelBase( | |
502 | flatbuffers::FlatBufferBuilder &_fbb, | |
503 | org::apache::arrow::computeir::flatbuf::Emit output_mapping_type = org::apache::arrow::computeir::flatbuf::Emit::NONE, | |
504 | flatbuffers::Offset<void> output_mapping = 0, | |
505 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelId> id = 0) { | |
506 | RelBaseBuilder builder_(_fbb); | |
507 | builder_.add_id(id); | |
508 | builder_.add_output_mapping(output_mapping); | |
509 | builder_.add_output_mapping_type(output_mapping_type); | |
510 | return builder_.Finish(); | |
511 | } | |
512 | ||
513 | /// Filter operation | |
514 | struct Filter FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
515 | typedef FilterBuilder Builder; | |
516 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
517 | VT_BASE = 4, | |
518 | VT_REL = 6, | |
519 | VT_PREDICATE = 8 | |
520 | }; | |
521 | /// Common options | |
522 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
523 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
524 | } | |
525 | /// Child relation | |
526 | const org::apache::arrow::computeir::flatbuf::Relation *rel() const { | |
527 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_REL); | |
528 | } | |
529 | /// The expression which will be evaluated against input rows | |
530 | /// to determine whether they should be excluded from the | |
531 | /// filter relation's output. | |
532 | const org::apache::arrow::computeir::flatbuf::Expression *predicate() const { | |
533 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Expression *>(VT_PREDICATE); | |
534 | } | |
535 | bool Verify(flatbuffers::Verifier &verifier) const { | |
536 | return VerifyTableStart(verifier) && | |
537 | VerifyOffsetRequired(verifier, VT_BASE) && | |
538 | verifier.VerifyTable(base()) && | |
539 | VerifyOffsetRequired(verifier, VT_REL) && | |
540 | verifier.VerifyTable(rel()) && | |
541 | VerifyOffsetRequired(verifier, VT_PREDICATE) && | |
542 | verifier.VerifyTable(predicate()) && | |
543 | verifier.EndTable(); | |
544 | } | |
545 | }; | |
546 | ||
547 | struct FilterBuilder { | |
548 | typedef Filter Table; | |
549 | flatbuffers::FlatBufferBuilder &fbb_; | |
550 | flatbuffers::uoffset_t start_; | |
551 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
552 | fbb_.AddOffset(Filter::VT_BASE, base); | |
553 | } | |
554 | void add_rel(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel) { | |
555 | fbb_.AddOffset(Filter::VT_REL, rel); | |
556 | } | |
557 | void add_predicate(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression> predicate) { | |
558 | fbb_.AddOffset(Filter::VT_PREDICATE, predicate); | |
559 | } | |
560 | explicit FilterBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
561 | : fbb_(_fbb) { | |
562 | start_ = fbb_.StartTable(); | |
563 | } | |
564 | FilterBuilder &operator=(const FilterBuilder &); | |
565 | flatbuffers::Offset<Filter> Finish() { | |
566 | const auto end = fbb_.EndTable(start_); | |
567 | auto o = flatbuffers::Offset<Filter>(end); | |
568 | fbb_.Required(o, Filter::VT_BASE); | |
569 | fbb_.Required(o, Filter::VT_REL); | |
570 | fbb_.Required(o, Filter::VT_PREDICATE); | |
571 | return o; | |
572 | } | |
573 | }; | |
574 | ||
575 | inline flatbuffers::Offset<Filter> CreateFilter( | |
576 | flatbuffers::FlatBufferBuilder &_fbb, | |
577 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
578 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
579 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression> predicate = 0) { | |
580 | FilterBuilder builder_(_fbb); | |
581 | builder_.add_predicate(predicate); | |
582 | builder_.add_rel(rel); | |
583 | builder_.add_base(base); | |
584 | return builder_.Finish(); | |
585 | } | |
586 | ||
587 | /// Projection | |
588 | struct Project FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
589 | typedef ProjectBuilder Builder; | |
590 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
591 | VT_BASE = 4, | |
592 | VT_REL = 6, | |
593 | VT_EXPRESSIONS = 8 | |
594 | }; | |
595 | /// Common options | |
596 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
597 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
598 | } | |
599 | /// Child relation | |
600 | const org::apache::arrow::computeir::flatbuf::Relation *rel() const { | |
601 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_REL); | |
602 | } | |
603 | /// Expressions which will be evaluated to produce to | |
604 | /// the rows of the project relation's output. | |
605 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *expressions() const { | |
606 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *>(VT_EXPRESSIONS); | |
607 | } | |
608 | bool Verify(flatbuffers::Verifier &verifier) const { | |
609 | return VerifyTableStart(verifier) && | |
610 | VerifyOffsetRequired(verifier, VT_BASE) && | |
611 | verifier.VerifyTable(base()) && | |
612 | VerifyOffsetRequired(verifier, VT_REL) && | |
613 | verifier.VerifyTable(rel()) && | |
614 | VerifyOffsetRequired(verifier, VT_EXPRESSIONS) && | |
615 | verifier.VerifyVector(expressions()) && | |
616 | verifier.VerifyVectorOfTables(expressions()) && | |
617 | verifier.EndTable(); | |
618 | } | |
619 | }; | |
620 | ||
621 | struct ProjectBuilder { | |
622 | typedef Project Table; | |
623 | flatbuffers::FlatBufferBuilder &fbb_; | |
624 | flatbuffers::uoffset_t start_; | |
625 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
626 | fbb_.AddOffset(Project::VT_BASE, base); | |
627 | } | |
628 | void add_rel(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel) { | |
629 | fbb_.AddOffset(Project::VT_REL, rel); | |
630 | } | |
631 | void add_expressions(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> expressions) { | |
632 | fbb_.AddOffset(Project::VT_EXPRESSIONS, expressions); | |
633 | } | |
634 | explicit ProjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
635 | : fbb_(_fbb) { | |
636 | start_ = fbb_.StartTable(); | |
637 | } | |
638 | ProjectBuilder &operator=(const ProjectBuilder &); | |
639 | flatbuffers::Offset<Project> Finish() { | |
640 | const auto end = fbb_.EndTable(start_); | |
641 | auto o = flatbuffers::Offset<Project>(end); | |
642 | fbb_.Required(o, Project::VT_BASE); | |
643 | fbb_.Required(o, Project::VT_REL); | |
644 | fbb_.Required(o, Project::VT_EXPRESSIONS); | |
645 | return o; | |
646 | } | |
647 | }; | |
648 | ||
649 | inline flatbuffers::Offset<Project> CreateProject( | |
650 | flatbuffers::FlatBufferBuilder &_fbb, | |
651 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
652 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
653 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> expressions = 0) { | |
654 | ProjectBuilder builder_(_fbb); | |
655 | builder_.add_expressions(expressions); | |
656 | builder_.add_rel(rel); | |
657 | builder_.add_base(base); | |
658 | return builder_.Finish(); | |
659 | } | |
660 | ||
661 | inline flatbuffers::Offset<Project> CreateProjectDirect( | |
662 | flatbuffers::FlatBufferBuilder &_fbb, | |
663 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
664 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
665 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *expressions = nullptr) { | |
666 | auto expressions__ = expressions ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>(*expressions) : 0; | |
667 | return org::apache::arrow::computeir::flatbuf::CreateProject( | |
668 | _fbb, | |
669 | base, | |
670 | rel, | |
671 | expressions__); | |
672 | } | |
673 | ||
674 | /// A set of grouping keys | |
675 | struct Grouping FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
676 | typedef GroupingBuilder Builder; | |
677 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
678 | VT_KEYS = 4 | |
679 | }; | |
680 | /// Expressions to group by | |
681 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *keys() const { | |
682 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *>(VT_KEYS); | |
683 | } | |
684 | bool Verify(flatbuffers::Verifier &verifier) const { | |
685 | return VerifyTableStart(verifier) && | |
686 | VerifyOffsetRequired(verifier, VT_KEYS) && | |
687 | verifier.VerifyVector(keys()) && | |
688 | verifier.VerifyVectorOfTables(keys()) && | |
689 | verifier.EndTable(); | |
690 | } | |
691 | }; | |
692 | ||
693 | struct GroupingBuilder { | |
694 | typedef Grouping Table; | |
695 | flatbuffers::FlatBufferBuilder &fbb_; | |
696 | flatbuffers::uoffset_t start_; | |
697 | void add_keys(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> keys) { | |
698 | fbb_.AddOffset(Grouping::VT_KEYS, keys); | |
699 | } | |
700 | explicit GroupingBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
701 | : fbb_(_fbb) { | |
702 | start_ = fbb_.StartTable(); | |
703 | } | |
704 | GroupingBuilder &operator=(const GroupingBuilder &); | |
705 | flatbuffers::Offset<Grouping> Finish() { | |
706 | const auto end = fbb_.EndTable(start_); | |
707 | auto o = flatbuffers::Offset<Grouping>(end); | |
708 | fbb_.Required(o, Grouping::VT_KEYS); | |
709 | return o; | |
710 | } | |
711 | }; | |
712 | ||
713 | inline flatbuffers::Offset<Grouping> CreateGrouping( | |
714 | flatbuffers::FlatBufferBuilder &_fbb, | |
715 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> keys = 0) { | |
716 | GroupingBuilder builder_(_fbb); | |
717 | builder_.add_keys(keys); | |
718 | return builder_.Finish(); | |
719 | } | |
720 | ||
721 | inline flatbuffers::Offset<Grouping> CreateGroupingDirect( | |
722 | flatbuffers::FlatBufferBuilder &_fbb, | |
723 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *keys = nullptr) { | |
724 | auto keys__ = keys ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>(*keys) : 0; | |
725 | return org::apache::arrow::computeir::flatbuf::CreateGrouping( | |
726 | _fbb, | |
727 | keys__); | |
728 | } | |
729 | ||
730 | /// Aggregate operation | |
731 | struct Aggregate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
732 | typedef AggregateBuilder Builder; | |
733 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
734 | VT_BASE = 4, | |
735 | VT_REL = 6, | |
736 | VT_MEASURES = 8, | |
737 | VT_GROUPINGS = 10 | |
738 | }; | |
739 | /// Common options | |
740 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
741 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
742 | } | |
743 | /// Child relation | |
744 | const org::apache::arrow::computeir::flatbuf::Relation *rel() const { | |
745 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_REL); | |
746 | } | |
747 | /// Expressions which will be evaluated to produce to | |
748 | /// the rows of the aggregate relation's output. | |
749 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *measures() const { | |
750 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *>(VT_MEASURES); | |
751 | } | |
752 | /// Keys by which `aggregations` will be grouped. | |
753 | /// | |
754 | /// The nested list here is to support grouping sets | |
755 | /// eg | |
756 | /// | |
757 | /// SELECT a, b, c, sum(d) | |
758 | /// FROM t | |
759 | /// GROUP BY | |
760 | /// GROUPING SETS ( | |
761 | /// (a, b, c), | |
762 | /// (a, b), | |
763 | /// (a), | |
764 | /// () | |
765 | /// ); | |
766 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>> *groupings() const { | |
767 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>> *>(VT_GROUPINGS); | |
768 | } | |
769 | bool Verify(flatbuffers::Verifier &verifier) const { | |
770 | return VerifyTableStart(verifier) && | |
771 | VerifyOffsetRequired(verifier, VT_BASE) && | |
772 | verifier.VerifyTable(base()) && | |
773 | VerifyOffsetRequired(verifier, VT_REL) && | |
774 | verifier.VerifyTable(rel()) && | |
775 | VerifyOffsetRequired(verifier, VT_MEASURES) && | |
776 | verifier.VerifyVector(measures()) && | |
777 | verifier.VerifyVectorOfTables(measures()) && | |
778 | VerifyOffsetRequired(verifier, VT_GROUPINGS) && | |
779 | verifier.VerifyVector(groupings()) && | |
780 | verifier.VerifyVectorOfTables(groupings()) && | |
781 | verifier.EndTable(); | |
782 | } | |
783 | }; | |
784 | ||
785 | struct AggregateBuilder { | |
786 | typedef Aggregate Table; | |
787 | flatbuffers::FlatBufferBuilder &fbb_; | |
788 | flatbuffers::uoffset_t start_; | |
789 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
790 | fbb_.AddOffset(Aggregate::VT_BASE, base); | |
791 | } | |
792 | void add_rel(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel) { | |
793 | fbb_.AddOffset(Aggregate::VT_REL, rel); | |
794 | } | |
795 | void add_measures(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> measures) { | |
796 | fbb_.AddOffset(Aggregate::VT_MEASURES, measures); | |
797 | } | |
798 | void add_groupings(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>>> groupings) { | |
799 | fbb_.AddOffset(Aggregate::VT_GROUPINGS, groupings); | |
800 | } | |
801 | explicit AggregateBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
802 | : fbb_(_fbb) { | |
803 | start_ = fbb_.StartTable(); | |
804 | } | |
805 | AggregateBuilder &operator=(const AggregateBuilder &); | |
806 | flatbuffers::Offset<Aggregate> Finish() { | |
807 | const auto end = fbb_.EndTable(start_); | |
808 | auto o = flatbuffers::Offset<Aggregate>(end); | |
809 | fbb_.Required(o, Aggregate::VT_BASE); | |
810 | fbb_.Required(o, Aggregate::VT_REL); | |
811 | fbb_.Required(o, Aggregate::VT_MEASURES); | |
812 | fbb_.Required(o, Aggregate::VT_GROUPINGS); | |
813 | return o; | |
814 | } | |
815 | }; | |
816 | ||
817 | inline flatbuffers::Offset<Aggregate> CreateAggregate( | |
818 | flatbuffers::FlatBufferBuilder &_fbb, | |
819 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
820 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
821 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>> measures = 0, | |
822 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>>> groupings = 0) { | |
823 | AggregateBuilder builder_(_fbb); | |
824 | builder_.add_groupings(groupings); | |
825 | builder_.add_measures(measures); | |
826 | builder_.add_rel(rel); | |
827 | builder_.add_base(base); | |
828 | return builder_.Finish(); | |
829 | } | |
830 | ||
831 | inline flatbuffers::Offset<Aggregate> CreateAggregateDirect( | |
832 | flatbuffers::FlatBufferBuilder &_fbb, | |
833 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
834 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
835 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>> *measures = nullptr, | |
836 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>> *groupings = nullptr) { | |
837 | auto measures__ = measures ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression>>(*measures) : 0; | |
838 | auto groupings__ = groupings ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Grouping>>(*groupings) : 0; | |
839 | return org::apache::arrow::computeir::flatbuf::CreateAggregate( | |
840 | _fbb, | |
841 | base, | |
842 | rel, | |
843 | measures__, | |
844 | groupings__); | |
845 | } | |
846 | ||
847 | /// Join between two tables | |
848 | struct Join FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
849 | typedef JoinBuilder Builder; | |
850 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
851 | VT_BASE = 4, | |
852 | VT_LEFT = 6, | |
853 | VT_RIGHT = 8, | |
854 | VT_ON_EXPRESSION = 10, | |
855 | VT_JOIN_KIND = 12 | |
856 | }; | |
857 | /// Common options | |
858 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
859 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
860 | } | |
861 | /// Left relation | |
862 | const org::apache::arrow::computeir::flatbuf::Relation *left() const { | |
863 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_LEFT); | |
864 | } | |
865 | /// Right relation | |
866 | const org::apache::arrow::computeir::flatbuf::Relation *right() const { | |
867 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_RIGHT); | |
868 | } | |
869 | /// The expression which will be evaluated against rows from each | |
870 | /// input to determine whether they should be included in the | |
871 | /// join relation's output. | |
872 | const org::apache::arrow::computeir::flatbuf::Expression *on_expression() const { | |
873 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Expression *>(VT_ON_EXPRESSION); | |
874 | } | |
875 | /// The kind of join to use. | |
876 | org::apache::arrow::computeir::flatbuf::JoinKind join_kind() const { | |
877 | return static_cast<org::apache::arrow::computeir::flatbuf::JoinKind>(GetField<uint8_t>(VT_JOIN_KIND, 0)); | |
878 | } | |
879 | bool Verify(flatbuffers::Verifier &verifier) const { | |
880 | return VerifyTableStart(verifier) && | |
881 | VerifyOffsetRequired(verifier, VT_BASE) && | |
882 | verifier.VerifyTable(base()) && | |
883 | VerifyOffsetRequired(verifier, VT_LEFT) && | |
884 | verifier.VerifyTable(left()) && | |
885 | VerifyOffsetRequired(verifier, VT_RIGHT) && | |
886 | verifier.VerifyTable(right()) && | |
887 | VerifyOffsetRequired(verifier, VT_ON_EXPRESSION) && | |
888 | verifier.VerifyTable(on_expression()) && | |
889 | VerifyField<uint8_t>(verifier, VT_JOIN_KIND) && | |
890 | verifier.EndTable(); | |
891 | } | |
892 | }; | |
893 | ||
894 | struct JoinBuilder { | |
895 | typedef Join Table; | |
896 | flatbuffers::FlatBufferBuilder &fbb_; | |
897 | flatbuffers::uoffset_t start_; | |
898 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
899 | fbb_.AddOffset(Join::VT_BASE, base); | |
900 | } | |
901 | void add_left(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> left) { | |
902 | fbb_.AddOffset(Join::VT_LEFT, left); | |
903 | } | |
904 | void add_right(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> right) { | |
905 | fbb_.AddOffset(Join::VT_RIGHT, right); | |
906 | } | |
907 | void add_on_expression(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression> on_expression) { | |
908 | fbb_.AddOffset(Join::VT_ON_EXPRESSION, on_expression); | |
909 | } | |
910 | void add_join_kind(org::apache::arrow::computeir::flatbuf::JoinKind join_kind) { | |
911 | fbb_.AddElement<uint8_t>(Join::VT_JOIN_KIND, static_cast<uint8_t>(join_kind), 0); | |
912 | } | |
913 | explicit JoinBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
914 | : fbb_(_fbb) { | |
915 | start_ = fbb_.StartTable(); | |
916 | } | |
917 | JoinBuilder &operator=(const JoinBuilder &); | |
918 | flatbuffers::Offset<Join> Finish() { | |
919 | const auto end = fbb_.EndTable(start_); | |
920 | auto o = flatbuffers::Offset<Join>(end); | |
921 | fbb_.Required(o, Join::VT_BASE); | |
922 | fbb_.Required(o, Join::VT_LEFT); | |
923 | fbb_.Required(o, Join::VT_RIGHT); | |
924 | fbb_.Required(o, Join::VT_ON_EXPRESSION); | |
925 | return o; | |
926 | } | |
927 | }; | |
928 | ||
929 | inline flatbuffers::Offset<Join> CreateJoin( | |
930 | flatbuffers::FlatBufferBuilder &_fbb, | |
931 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
932 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> left = 0, | |
933 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> right = 0, | |
934 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Expression> on_expression = 0, | |
935 | org::apache::arrow::computeir::flatbuf::JoinKind join_kind = org::apache::arrow::computeir::flatbuf::JoinKind::Anti) { | |
936 | JoinBuilder builder_(_fbb); | |
937 | builder_.add_on_expression(on_expression); | |
938 | builder_.add_right(right); | |
939 | builder_.add_left(left); | |
940 | builder_.add_base(base); | |
941 | builder_.add_join_kind(join_kind); | |
942 | return builder_.Finish(); | |
943 | } | |
944 | ||
945 | /// Order by relation | |
946 | struct OrderBy FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
947 | typedef OrderByBuilder Builder; | |
948 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
949 | VT_BASE = 4, | |
950 | VT_REL = 6, | |
951 | VT_KEYS = 8 | |
952 | }; | |
953 | /// Common options | |
954 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
955 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
956 | } | |
957 | /// Child relation | |
958 | const org::apache::arrow::computeir::flatbuf::Relation *rel() const { | |
959 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_REL); | |
960 | } | |
961 | /// Define sort order for rows of output. | |
962 | /// Keys with higher precedence are ordered ahead of other keys. | |
963 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>> *keys() const { | |
964 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>> *>(VT_KEYS); | |
965 | } | |
966 | bool Verify(flatbuffers::Verifier &verifier) const { | |
967 | return VerifyTableStart(verifier) && | |
968 | VerifyOffsetRequired(verifier, VT_BASE) && | |
969 | verifier.VerifyTable(base()) && | |
970 | VerifyOffsetRequired(verifier, VT_REL) && | |
971 | verifier.VerifyTable(rel()) && | |
972 | VerifyOffsetRequired(verifier, VT_KEYS) && | |
973 | verifier.VerifyVector(keys()) && | |
974 | verifier.VerifyVectorOfTables(keys()) && | |
975 | verifier.EndTable(); | |
976 | } | |
977 | }; | |
978 | ||
979 | struct OrderByBuilder { | |
980 | typedef OrderBy Table; | |
981 | flatbuffers::FlatBufferBuilder &fbb_; | |
982 | flatbuffers::uoffset_t start_; | |
983 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
984 | fbb_.AddOffset(OrderBy::VT_BASE, base); | |
985 | } | |
986 | void add_rel(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel) { | |
987 | fbb_.AddOffset(OrderBy::VT_REL, rel); | |
988 | } | |
989 | void add_keys(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>>> keys) { | |
990 | fbb_.AddOffset(OrderBy::VT_KEYS, keys); | |
991 | } | |
992 | explicit OrderByBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
993 | : fbb_(_fbb) { | |
994 | start_ = fbb_.StartTable(); | |
995 | } | |
996 | OrderByBuilder &operator=(const OrderByBuilder &); | |
997 | flatbuffers::Offset<OrderBy> Finish() { | |
998 | const auto end = fbb_.EndTable(start_); | |
999 | auto o = flatbuffers::Offset<OrderBy>(end); | |
1000 | fbb_.Required(o, OrderBy::VT_BASE); | |
1001 | fbb_.Required(o, OrderBy::VT_REL); | |
1002 | fbb_.Required(o, OrderBy::VT_KEYS); | |
1003 | return o; | |
1004 | } | |
1005 | }; | |
1006 | ||
1007 | inline flatbuffers::Offset<OrderBy> CreateOrderBy( | |
1008 | flatbuffers::FlatBufferBuilder &_fbb, | |
1009 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1010 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
1011 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>>> keys = 0) { | |
1012 | OrderByBuilder builder_(_fbb); | |
1013 | builder_.add_keys(keys); | |
1014 | builder_.add_rel(rel); | |
1015 | builder_.add_base(base); | |
1016 | return builder_.Finish(); | |
1017 | } | |
1018 | ||
1019 | inline flatbuffers::Offset<OrderBy> CreateOrderByDirect( | |
1020 | flatbuffers::FlatBufferBuilder &_fbb, | |
1021 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1022 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
1023 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>> *keys = nullptr) { | |
1024 | auto keys__ = keys ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::SortKey>>(*keys) : 0; | |
1025 | return org::apache::arrow::computeir::flatbuf::CreateOrderBy( | |
1026 | _fbb, | |
1027 | base, | |
1028 | rel, | |
1029 | keys__); | |
1030 | } | |
1031 | ||
1032 | /// Limit operation | |
1033 | struct Limit FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1034 | typedef LimitBuilder Builder; | |
1035 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1036 | VT_BASE = 4, | |
1037 | VT_REL = 6, | |
1038 | VT_OFFSET = 8, | |
1039 | VT_COUNT = 10 | |
1040 | }; | |
1041 | /// Common options | |
1042 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
1043 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
1044 | } | |
1045 | /// Child relation | |
1046 | const org::apache::arrow::computeir::flatbuf::Relation *rel() const { | |
1047 | return GetPointer<const org::apache::arrow::computeir::flatbuf::Relation *>(VT_REL); | |
1048 | } | |
1049 | /// Starting index of rows | |
1050 | uint32_t offset() const { | |
1051 | return GetField<uint32_t>(VT_OFFSET, 0); | |
1052 | } | |
1053 | /// The maximum number of rows of output. | |
1054 | uint32_t count() const { | |
1055 | return GetField<uint32_t>(VT_COUNT, 0); | |
1056 | } | |
1057 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1058 | return VerifyTableStart(verifier) && | |
1059 | VerifyOffsetRequired(verifier, VT_BASE) && | |
1060 | verifier.VerifyTable(base()) && | |
1061 | VerifyOffsetRequired(verifier, VT_REL) && | |
1062 | verifier.VerifyTable(rel()) && | |
1063 | VerifyField<uint32_t>(verifier, VT_OFFSET) && | |
1064 | VerifyField<uint32_t>(verifier, VT_COUNT) && | |
1065 | verifier.EndTable(); | |
1066 | } | |
1067 | }; | |
1068 | ||
1069 | struct LimitBuilder { | |
1070 | typedef Limit Table; | |
1071 | flatbuffers::FlatBufferBuilder &fbb_; | |
1072 | flatbuffers::uoffset_t start_; | |
1073 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
1074 | fbb_.AddOffset(Limit::VT_BASE, base); | |
1075 | } | |
1076 | void add_rel(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel) { | |
1077 | fbb_.AddOffset(Limit::VT_REL, rel); | |
1078 | } | |
1079 | void add_offset(uint32_t offset) { | |
1080 | fbb_.AddElement<uint32_t>(Limit::VT_OFFSET, offset, 0); | |
1081 | } | |
1082 | void add_count(uint32_t count) { | |
1083 | fbb_.AddElement<uint32_t>(Limit::VT_COUNT, count, 0); | |
1084 | } | |
1085 | explicit LimitBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1086 | : fbb_(_fbb) { | |
1087 | start_ = fbb_.StartTable(); | |
1088 | } | |
1089 | LimitBuilder &operator=(const LimitBuilder &); | |
1090 | flatbuffers::Offset<Limit> Finish() { | |
1091 | const auto end = fbb_.EndTable(start_); | |
1092 | auto o = flatbuffers::Offset<Limit>(end); | |
1093 | fbb_.Required(o, Limit::VT_BASE); | |
1094 | fbb_.Required(o, Limit::VT_REL); | |
1095 | return o; | |
1096 | } | |
1097 | }; | |
1098 | ||
1099 | inline flatbuffers::Offset<Limit> CreateLimit( | |
1100 | flatbuffers::FlatBufferBuilder &_fbb, | |
1101 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1102 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> rel = 0, | |
1103 | uint32_t offset = 0, | |
1104 | uint32_t count = 0) { | |
1105 | LimitBuilder builder_(_fbb); | |
1106 | builder_.add_count(count); | |
1107 | builder_.add_offset(offset); | |
1108 | builder_.add_rel(rel); | |
1109 | builder_.add_base(base); | |
1110 | return builder_.Finish(); | |
1111 | } | |
1112 | ||
1113 | /// A set operation on two or more relations | |
1114 | struct SetOperation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1115 | typedef SetOperationBuilder Builder; | |
1116 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1117 | VT_BASE = 4, | |
1118 | VT_RELS = 6, | |
1119 | VT_SET_OP = 8 | |
1120 | }; | |
1121 | /// Common options | |
1122 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
1123 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
1124 | } | |
1125 | /// Child relations | |
1126 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>> *rels() const { | |
1127 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>> *>(VT_RELS); | |
1128 | } | |
1129 | /// The kind of set operation | |
1130 | org::apache::arrow::computeir::flatbuf::SetOpKind set_op() const { | |
1131 | return static_cast<org::apache::arrow::computeir::flatbuf::SetOpKind>(GetField<uint8_t>(VT_SET_OP, 0)); | |
1132 | } | |
1133 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1134 | return VerifyTableStart(verifier) && | |
1135 | VerifyOffsetRequired(verifier, VT_BASE) && | |
1136 | verifier.VerifyTable(base()) && | |
1137 | VerifyOffsetRequired(verifier, VT_RELS) && | |
1138 | verifier.VerifyVector(rels()) && | |
1139 | verifier.VerifyVectorOfTables(rels()) && | |
1140 | VerifyField<uint8_t>(verifier, VT_SET_OP) && | |
1141 | verifier.EndTable(); | |
1142 | } | |
1143 | }; | |
1144 | ||
1145 | struct SetOperationBuilder { | |
1146 | typedef SetOperation Table; | |
1147 | flatbuffers::FlatBufferBuilder &fbb_; | |
1148 | flatbuffers::uoffset_t start_; | |
1149 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
1150 | fbb_.AddOffset(SetOperation::VT_BASE, base); | |
1151 | } | |
1152 | void add_rels(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>>> rels) { | |
1153 | fbb_.AddOffset(SetOperation::VT_RELS, rels); | |
1154 | } | |
1155 | void add_set_op(org::apache::arrow::computeir::flatbuf::SetOpKind set_op) { | |
1156 | fbb_.AddElement<uint8_t>(SetOperation::VT_SET_OP, static_cast<uint8_t>(set_op), 0); | |
1157 | } | |
1158 | explicit SetOperationBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1159 | : fbb_(_fbb) { | |
1160 | start_ = fbb_.StartTable(); | |
1161 | } | |
1162 | SetOperationBuilder &operator=(const SetOperationBuilder &); | |
1163 | flatbuffers::Offset<SetOperation> Finish() { | |
1164 | const auto end = fbb_.EndTable(start_); | |
1165 | auto o = flatbuffers::Offset<SetOperation>(end); | |
1166 | fbb_.Required(o, SetOperation::VT_BASE); | |
1167 | fbb_.Required(o, SetOperation::VT_RELS); | |
1168 | return o; | |
1169 | } | |
1170 | }; | |
1171 | ||
1172 | inline flatbuffers::Offset<SetOperation> CreateSetOperation( | |
1173 | flatbuffers::FlatBufferBuilder &_fbb, | |
1174 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1175 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>>> rels = 0, | |
1176 | org::apache::arrow::computeir::flatbuf::SetOpKind set_op = org::apache::arrow::computeir::flatbuf::SetOpKind::Union) { | |
1177 | SetOperationBuilder builder_(_fbb); | |
1178 | builder_.add_rels(rels); | |
1179 | builder_.add_base(base); | |
1180 | builder_.add_set_op(set_op); | |
1181 | return builder_.Finish(); | |
1182 | } | |
1183 | ||
1184 | inline flatbuffers::Offset<SetOperation> CreateSetOperationDirect( | |
1185 | flatbuffers::FlatBufferBuilder &_fbb, | |
1186 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1187 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>> *rels = nullptr, | |
1188 | org::apache::arrow::computeir::flatbuf::SetOpKind set_op = org::apache::arrow::computeir::flatbuf::SetOpKind::Union) { | |
1189 | auto rels__ = rels ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation>>(*rels) : 0; | |
1190 | return org::apache::arrow::computeir::flatbuf::CreateSetOperation( | |
1191 | _fbb, | |
1192 | base, | |
1193 | rels__, | |
1194 | set_op); | |
1195 | } | |
1196 | ||
1197 | /// A single column of literal values. | |
1198 | struct LiteralColumn FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1199 | typedef LiteralColumnBuilder Builder; | |
1200 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1201 | VT_ELEMENTS = 4 | |
1202 | }; | |
1203 | /// The literal values of the column | |
1204 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>> *elements() const { | |
1205 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>> *>(VT_ELEMENTS); | |
1206 | } | |
1207 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1208 | return VerifyTableStart(verifier) && | |
1209 | VerifyOffsetRequired(verifier, VT_ELEMENTS) && | |
1210 | verifier.VerifyVector(elements()) && | |
1211 | verifier.VerifyVectorOfTables(elements()) && | |
1212 | verifier.EndTable(); | |
1213 | } | |
1214 | }; | |
1215 | ||
1216 | struct LiteralColumnBuilder { | |
1217 | typedef LiteralColumn Table; | |
1218 | flatbuffers::FlatBufferBuilder &fbb_; | |
1219 | flatbuffers::uoffset_t start_; | |
1220 | void add_elements(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>>> elements) { | |
1221 | fbb_.AddOffset(LiteralColumn::VT_ELEMENTS, elements); | |
1222 | } | |
1223 | explicit LiteralColumnBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1224 | : fbb_(_fbb) { | |
1225 | start_ = fbb_.StartTable(); | |
1226 | } | |
1227 | LiteralColumnBuilder &operator=(const LiteralColumnBuilder &); | |
1228 | flatbuffers::Offset<LiteralColumn> Finish() { | |
1229 | const auto end = fbb_.EndTable(start_); | |
1230 | auto o = flatbuffers::Offset<LiteralColumn>(end); | |
1231 | fbb_.Required(o, LiteralColumn::VT_ELEMENTS); | |
1232 | return o; | |
1233 | } | |
1234 | }; | |
1235 | ||
1236 | inline flatbuffers::Offset<LiteralColumn> CreateLiteralColumn( | |
1237 | flatbuffers::FlatBufferBuilder &_fbb, | |
1238 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>>> elements = 0) { | |
1239 | LiteralColumnBuilder builder_(_fbb); | |
1240 | builder_.add_elements(elements); | |
1241 | return builder_.Finish(); | |
1242 | } | |
1243 | ||
1244 | inline flatbuffers::Offset<LiteralColumn> CreateLiteralColumnDirect( | |
1245 | flatbuffers::FlatBufferBuilder &_fbb, | |
1246 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>> *elements = nullptr) { | |
1247 | auto elements__ = elements ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Literal>>(*elements) : 0; | |
1248 | return org::apache::arrow::computeir::flatbuf::CreateLiteralColumn( | |
1249 | _fbb, | |
1250 | elements__); | |
1251 | } | |
1252 | ||
1253 | /// Literal relation | |
1254 | struct LiteralRelation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1255 | typedef LiteralRelationBuilder Builder; | |
1256 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1257 | VT_BASE = 4, | |
1258 | VT_COLUMNS = 6 | |
1259 | }; | |
1260 | /// Common options | |
1261 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
1262 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
1263 | } | |
1264 | /// The columns of this literal relation. | |
1265 | const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>> *columns() const { | |
1266 | return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>> *>(VT_COLUMNS); | |
1267 | } | |
1268 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1269 | return VerifyTableStart(verifier) && | |
1270 | VerifyOffsetRequired(verifier, VT_BASE) && | |
1271 | verifier.VerifyTable(base()) && | |
1272 | VerifyOffsetRequired(verifier, VT_COLUMNS) && | |
1273 | verifier.VerifyVector(columns()) && | |
1274 | verifier.VerifyVectorOfTables(columns()) && | |
1275 | verifier.EndTable(); | |
1276 | } | |
1277 | }; | |
1278 | ||
1279 | struct LiteralRelationBuilder { | |
1280 | typedef LiteralRelation Table; | |
1281 | flatbuffers::FlatBufferBuilder &fbb_; | |
1282 | flatbuffers::uoffset_t start_; | |
1283 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
1284 | fbb_.AddOffset(LiteralRelation::VT_BASE, base); | |
1285 | } | |
1286 | void add_columns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>>> columns) { | |
1287 | fbb_.AddOffset(LiteralRelation::VT_COLUMNS, columns); | |
1288 | } | |
1289 | explicit LiteralRelationBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1290 | : fbb_(_fbb) { | |
1291 | start_ = fbb_.StartTable(); | |
1292 | } | |
1293 | LiteralRelationBuilder &operator=(const LiteralRelationBuilder &); | |
1294 | flatbuffers::Offset<LiteralRelation> Finish() { | |
1295 | const auto end = fbb_.EndTable(start_); | |
1296 | auto o = flatbuffers::Offset<LiteralRelation>(end); | |
1297 | fbb_.Required(o, LiteralRelation::VT_BASE); | |
1298 | fbb_.Required(o, LiteralRelation::VT_COLUMNS); | |
1299 | return o; | |
1300 | } | |
1301 | }; | |
1302 | ||
1303 | inline flatbuffers::Offset<LiteralRelation> CreateLiteralRelation( | |
1304 | flatbuffers::FlatBufferBuilder &_fbb, | |
1305 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1306 | flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>>> columns = 0) { | |
1307 | LiteralRelationBuilder builder_(_fbb); | |
1308 | builder_.add_columns(columns); | |
1309 | builder_.add_base(base); | |
1310 | return builder_.Finish(); | |
1311 | } | |
1312 | ||
1313 | inline flatbuffers::Offset<LiteralRelation> CreateLiteralRelationDirect( | |
1314 | flatbuffers::FlatBufferBuilder &_fbb, | |
1315 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1316 | const std::vector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>> *columns = nullptr) { | |
1317 | auto columns__ = columns ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::LiteralColumn>>(*columns) : 0; | |
1318 | return org::apache::arrow::computeir::flatbuf::CreateLiteralRelation( | |
1319 | _fbb, | |
1320 | base, | |
1321 | columns__); | |
1322 | } | |
1323 | ||
1324 | /// An external source of tabular data | |
1325 | struct Source FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1326 | typedef SourceBuilder Builder; | |
1327 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1328 | VT_BASE = 4, | |
1329 | VT_NAME = 6, | |
1330 | VT_SCHEMA = 8 | |
1331 | }; | |
1332 | const org::apache::arrow::computeir::flatbuf::RelBase *base() const { | |
1333 | return GetPointer<const org::apache::arrow::computeir::flatbuf::RelBase *>(VT_BASE); | |
1334 | } | |
1335 | const flatbuffers::String *name() const { | |
1336 | return GetPointer<const flatbuffers::String *>(VT_NAME); | |
1337 | } | |
1338 | const org::apache::arrow::flatbuf::Schema *schema() const { | |
1339 | return GetPointer<const org::apache::arrow::flatbuf::Schema *>(VT_SCHEMA); | |
1340 | } | |
1341 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1342 | return VerifyTableStart(verifier) && | |
1343 | VerifyOffsetRequired(verifier, VT_BASE) && | |
1344 | verifier.VerifyTable(base()) && | |
1345 | VerifyOffsetRequired(verifier, VT_NAME) && | |
1346 | verifier.VerifyString(name()) && | |
1347 | VerifyOffsetRequired(verifier, VT_SCHEMA) && | |
1348 | verifier.VerifyTable(schema()) && | |
1349 | verifier.EndTable(); | |
1350 | } | |
1351 | }; | |
1352 | ||
1353 | struct SourceBuilder { | |
1354 | typedef Source Table; | |
1355 | flatbuffers::FlatBufferBuilder &fbb_; | |
1356 | flatbuffers::uoffset_t start_; | |
1357 | void add_base(flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base) { | |
1358 | fbb_.AddOffset(Source::VT_BASE, base); | |
1359 | } | |
1360 | void add_name(flatbuffers::Offset<flatbuffers::String> name) { | |
1361 | fbb_.AddOffset(Source::VT_NAME, name); | |
1362 | } | |
1363 | void add_schema(flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema) { | |
1364 | fbb_.AddOffset(Source::VT_SCHEMA, schema); | |
1365 | } | |
1366 | explicit SourceBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1367 | : fbb_(_fbb) { | |
1368 | start_ = fbb_.StartTable(); | |
1369 | } | |
1370 | SourceBuilder &operator=(const SourceBuilder &); | |
1371 | flatbuffers::Offset<Source> Finish() { | |
1372 | const auto end = fbb_.EndTable(start_); | |
1373 | auto o = flatbuffers::Offset<Source>(end); | |
1374 | fbb_.Required(o, Source::VT_BASE); | |
1375 | fbb_.Required(o, Source::VT_NAME); | |
1376 | fbb_.Required(o, Source::VT_SCHEMA); | |
1377 | return o; | |
1378 | } | |
1379 | }; | |
1380 | ||
1381 | inline flatbuffers::Offset<Source> CreateSource( | |
1382 | flatbuffers::FlatBufferBuilder &_fbb, | |
1383 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1384 | flatbuffers::Offset<flatbuffers::String> name = 0, | |
1385 | flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0) { | |
1386 | SourceBuilder builder_(_fbb); | |
1387 | builder_.add_schema(schema); | |
1388 | builder_.add_name(name); | |
1389 | builder_.add_base(base); | |
1390 | return builder_.Finish(); | |
1391 | } | |
1392 | ||
1393 | inline flatbuffers::Offset<Source> CreateSourceDirect( | |
1394 | flatbuffers::FlatBufferBuilder &_fbb, | |
1395 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::RelBase> base = 0, | |
1396 | const char *name = nullptr, | |
1397 | flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0) { | |
1398 | auto name__ = name ? _fbb.CreateString(name) : 0; | |
1399 | return org::apache::arrow::computeir::flatbuf::CreateSource( | |
1400 | _fbb, | |
1401 | base, | |
1402 | name__, | |
1403 | schema); | |
1404 | } | |
1405 | ||
1406 | /// A table holding an instance of the possible relation types. | |
1407 | struct Relation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { | |
1408 | typedef RelationBuilder Builder; | |
1409 | enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { | |
1410 | VT_IMPL_TYPE = 4, | |
1411 | VT_IMPL = 6 | |
1412 | }; | |
1413 | org::apache::arrow::computeir::flatbuf::RelationImpl impl_type() const { | |
1414 | return static_cast<org::apache::arrow::computeir::flatbuf::RelationImpl>(GetField<uint8_t>(VT_IMPL_TYPE, 0)); | |
1415 | } | |
1416 | const void *impl() const { | |
1417 | return GetPointer<const void *>(VT_IMPL); | |
1418 | } | |
1419 | template<typename T> const T *impl_as() const; | |
1420 | const org::apache::arrow::computeir::flatbuf::Aggregate *impl_as_Aggregate() const { | |
1421 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Aggregate ? static_cast<const org::apache::arrow::computeir::flatbuf::Aggregate *>(impl()) : nullptr; | |
1422 | } | |
1423 | const org::apache::arrow::computeir::flatbuf::Filter *impl_as_Filter() const { | |
1424 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Filter ? static_cast<const org::apache::arrow::computeir::flatbuf::Filter *>(impl()) : nullptr; | |
1425 | } | |
1426 | const org::apache::arrow::computeir::flatbuf::Join *impl_as_Join() const { | |
1427 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Join ? static_cast<const org::apache::arrow::computeir::flatbuf::Join *>(impl()) : nullptr; | |
1428 | } | |
1429 | const org::apache::arrow::computeir::flatbuf::Limit *impl_as_Limit() const { | |
1430 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Limit ? static_cast<const org::apache::arrow::computeir::flatbuf::Limit *>(impl()) : nullptr; | |
1431 | } | |
1432 | const org::apache::arrow::computeir::flatbuf::LiteralRelation *impl_as_LiteralRelation() const { | |
1433 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::LiteralRelation ? static_cast<const org::apache::arrow::computeir::flatbuf::LiteralRelation *>(impl()) : nullptr; | |
1434 | } | |
1435 | const org::apache::arrow::computeir::flatbuf::OrderBy *impl_as_OrderBy() const { | |
1436 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::OrderBy ? static_cast<const org::apache::arrow::computeir::flatbuf::OrderBy *>(impl()) : nullptr; | |
1437 | } | |
1438 | const org::apache::arrow::computeir::flatbuf::Project *impl_as_Project() const { | |
1439 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Project ? static_cast<const org::apache::arrow::computeir::flatbuf::Project *>(impl()) : nullptr; | |
1440 | } | |
1441 | const org::apache::arrow::computeir::flatbuf::SetOperation *impl_as_SetOperation() const { | |
1442 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::SetOperation ? static_cast<const org::apache::arrow::computeir::flatbuf::SetOperation *>(impl()) : nullptr; | |
1443 | } | |
1444 | const org::apache::arrow::computeir::flatbuf::Source *impl_as_Source() const { | |
1445 | return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Source ? static_cast<const org::apache::arrow::computeir::flatbuf::Source *>(impl()) : nullptr; | |
1446 | } | |
1447 | bool Verify(flatbuffers::Verifier &verifier) const { | |
1448 | return VerifyTableStart(verifier) && | |
1449 | VerifyField<uint8_t>(verifier, VT_IMPL_TYPE) && | |
1450 | VerifyOffsetRequired(verifier, VT_IMPL) && | |
1451 | VerifyRelationImpl(verifier, impl(), impl_type()) && | |
1452 | verifier.EndTable(); | |
1453 | } | |
1454 | }; | |
1455 | ||
1456 | template<> inline const org::apache::arrow::computeir::flatbuf::Aggregate *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Aggregate>() const { | |
1457 | return impl_as_Aggregate(); | |
1458 | } | |
1459 | ||
1460 | template<> inline const org::apache::arrow::computeir::flatbuf::Filter *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Filter>() const { | |
1461 | return impl_as_Filter(); | |
1462 | } | |
1463 | ||
1464 | template<> inline const org::apache::arrow::computeir::flatbuf::Join *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Join>() const { | |
1465 | return impl_as_Join(); | |
1466 | } | |
1467 | ||
1468 | template<> inline const org::apache::arrow::computeir::flatbuf::Limit *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Limit>() const { | |
1469 | return impl_as_Limit(); | |
1470 | } | |
1471 | ||
1472 | template<> inline const org::apache::arrow::computeir::flatbuf::LiteralRelation *Relation::impl_as<org::apache::arrow::computeir::flatbuf::LiteralRelation>() const { | |
1473 | return impl_as_LiteralRelation(); | |
1474 | } | |
1475 | ||
1476 | template<> inline const org::apache::arrow::computeir::flatbuf::OrderBy *Relation::impl_as<org::apache::arrow::computeir::flatbuf::OrderBy>() const { | |
1477 | return impl_as_OrderBy(); | |
1478 | } | |
1479 | ||
1480 | template<> inline const org::apache::arrow::computeir::flatbuf::Project *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Project>() const { | |
1481 | return impl_as_Project(); | |
1482 | } | |
1483 | ||
1484 | template<> inline const org::apache::arrow::computeir::flatbuf::SetOperation *Relation::impl_as<org::apache::arrow::computeir::flatbuf::SetOperation>() const { | |
1485 | return impl_as_SetOperation(); | |
1486 | } | |
1487 | ||
1488 | template<> inline const org::apache::arrow::computeir::flatbuf::Source *Relation::impl_as<org::apache::arrow::computeir::flatbuf::Source>() const { | |
1489 | return impl_as_Source(); | |
1490 | } | |
1491 | ||
1492 | struct RelationBuilder { | |
1493 | typedef Relation Table; | |
1494 | flatbuffers::FlatBufferBuilder &fbb_; | |
1495 | flatbuffers::uoffset_t start_; | |
1496 | void add_impl_type(org::apache::arrow::computeir::flatbuf::RelationImpl impl_type) { | |
1497 | fbb_.AddElement<uint8_t>(Relation::VT_IMPL_TYPE, static_cast<uint8_t>(impl_type), 0); | |
1498 | } | |
1499 | void add_impl(flatbuffers::Offset<void> impl) { | |
1500 | fbb_.AddOffset(Relation::VT_IMPL, impl); | |
1501 | } | |
1502 | explicit RelationBuilder(flatbuffers::FlatBufferBuilder &_fbb) | |
1503 | : fbb_(_fbb) { | |
1504 | start_ = fbb_.StartTable(); | |
1505 | } | |
1506 | RelationBuilder &operator=(const RelationBuilder &); | |
1507 | flatbuffers::Offset<Relation> Finish() { | |
1508 | const auto end = fbb_.EndTable(start_); | |
1509 | auto o = flatbuffers::Offset<Relation>(end); | |
1510 | fbb_.Required(o, Relation::VT_IMPL); | |
1511 | return o; | |
1512 | } | |
1513 | }; | |
1514 | ||
1515 | inline flatbuffers::Offset<Relation> CreateRelation( | |
1516 | flatbuffers::FlatBufferBuilder &_fbb, | |
1517 | org::apache::arrow::computeir::flatbuf::RelationImpl impl_type = org::apache::arrow::computeir::flatbuf::RelationImpl::NONE, | |
1518 | flatbuffers::Offset<void> impl = 0) { | |
1519 | RelationBuilder builder_(_fbb); | |
1520 | builder_.add_impl(impl); | |
1521 | builder_.add_impl_type(impl_type); | |
1522 | return builder_.Finish(); | |
1523 | } | |
1524 | ||
1525 | inline bool VerifyEmit(flatbuffers::Verifier &verifier, const void *obj, Emit type) { | |
1526 | switch (type) { | |
1527 | case Emit::NONE: { | |
1528 | return true; | |
1529 | } | |
1530 | case Emit::Remap: { | |
1531 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Remap *>(obj); | |
1532 | return verifier.VerifyTable(ptr); | |
1533 | } | |
1534 | case Emit::PassThrough: { | |
1535 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::PassThrough *>(obj); | |
1536 | return verifier.VerifyTable(ptr); | |
1537 | } | |
1538 | default: return true; | |
1539 | } | |
1540 | } | |
1541 | ||
1542 | inline bool VerifyEmitVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { | |
1543 | if (!values || !types) return !values && !types; | |
1544 | if (values->size() != types->size()) return false; | |
1545 | for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { | |
1546 | if (!VerifyEmit( | |
1547 | verifier, values->Get(i), types->GetEnum<Emit>(i))) { | |
1548 | return false; | |
1549 | } | |
1550 | } | |
1551 | return true; | |
1552 | } | |
1553 | ||
1554 | inline bool VerifyRelationImpl(flatbuffers::Verifier &verifier, const void *obj, RelationImpl type) { | |
1555 | switch (type) { | |
1556 | case RelationImpl::NONE: { | |
1557 | return true; | |
1558 | } | |
1559 | case RelationImpl::Aggregate: { | |
1560 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Aggregate *>(obj); | |
1561 | return verifier.VerifyTable(ptr); | |
1562 | } | |
1563 | case RelationImpl::Filter: { | |
1564 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Filter *>(obj); | |
1565 | return verifier.VerifyTable(ptr); | |
1566 | } | |
1567 | case RelationImpl::Join: { | |
1568 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Join *>(obj); | |
1569 | return verifier.VerifyTable(ptr); | |
1570 | } | |
1571 | case RelationImpl::Limit: { | |
1572 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Limit *>(obj); | |
1573 | return verifier.VerifyTable(ptr); | |
1574 | } | |
1575 | case RelationImpl::LiteralRelation: { | |
1576 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::LiteralRelation *>(obj); | |
1577 | return verifier.VerifyTable(ptr); | |
1578 | } | |
1579 | case RelationImpl::OrderBy: { | |
1580 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::OrderBy *>(obj); | |
1581 | return verifier.VerifyTable(ptr); | |
1582 | } | |
1583 | case RelationImpl::Project: { | |
1584 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Project *>(obj); | |
1585 | return verifier.VerifyTable(ptr); | |
1586 | } | |
1587 | case RelationImpl::SetOperation: { | |
1588 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::SetOperation *>(obj); | |
1589 | return verifier.VerifyTable(ptr); | |
1590 | } | |
1591 | case RelationImpl::Source: { | |
1592 | auto ptr = reinterpret_cast<const org::apache::arrow::computeir::flatbuf::Source *>(obj); | |
1593 | return verifier.VerifyTable(ptr); | |
1594 | } | |
1595 | default: return true; | |
1596 | } | |
1597 | } | |
1598 | ||
1599 | inline bool VerifyRelationImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { | |
1600 | if (!values || !types) return !values && !types; | |
1601 | if (values->size() != types->size()) return false; | |
1602 | for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { | |
1603 | if (!VerifyRelationImpl( | |
1604 | verifier, values->Get(i), types->GetEnum<RelationImpl>(i))) { | |
1605 | return false; | |
1606 | } | |
1607 | } | |
1608 | return true; | |
1609 | } | |
1610 | ||
1611 | inline const org::apache::arrow::computeir::flatbuf::Relation *GetRelation(const void *buf) { | |
1612 | return flatbuffers::GetRoot<org::apache::arrow::computeir::flatbuf::Relation>(buf); | |
1613 | } | |
1614 | ||
1615 | inline const org::apache::arrow::computeir::flatbuf::Relation *GetSizePrefixedRelation(const void *buf) { | |
1616 | return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::computeir::flatbuf::Relation>(buf); | |
1617 | } | |
1618 | ||
1619 | inline bool VerifyRelationBuffer( | |
1620 | flatbuffers::Verifier &verifier) { | |
1621 | return verifier.VerifyBuffer<org::apache::arrow::computeir::flatbuf::Relation>(nullptr); | |
1622 | } | |
1623 | ||
1624 | inline bool VerifySizePrefixedRelationBuffer( | |
1625 | flatbuffers::Verifier &verifier) { | |
1626 | return verifier.VerifySizePrefixedBuffer<org::apache::arrow::computeir::flatbuf::Relation>(nullptr); | |
1627 | } | |
1628 | ||
1629 | inline void FinishRelationBuffer( | |
1630 | flatbuffers::FlatBufferBuilder &fbb, | |
1631 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> root) { | |
1632 | fbb.Finish(root); | |
1633 | } | |
1634 | ||
1635 | inline void FinishSizePrefixedRelationBuffer( | |
1636 | flatbuffers::FlatBufferBuilder &fbb, | |
1637 | flatbuffers::Offset<org::apache::arrow::computeir::flatbuf::Relation> root) { | |
1638 | fbb.FinishSizePrefixed(root); | |
1639 | } | |
1640 | ||
1641 | } // namespace flatbuf | |
1642 | } // namespace computeir | |
1643 | } // namespace arrow | |
1644 | } // namespace apache | |
1645 | } // namespace org | |
1646 | ||
1647 | #endif // FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ |