diff --git a/.gitattributes b/.gitattributes index fac7bf85a77f1..5118abc1f3bfc 100644 --- a/.gitattributes +++ b/.gitattributes @@ -3,4 +3,4 @@ r/R/arrowExports.R linguist-generated=true r/src/RcppExports.cpp linguist-generated=true r/src/arrowExports.cpp linguist-generated=true r/man/*.Rd linguist-generated=true - +cpp/src/generated/*.h linguist-generated=true diff --git a/cpp/build-support/lint_exclusions.txt b/cpp/build-support/lint_exclusions.txt index 01642a58008ca..785d07aa9d539 100644 --- a/cpp/build-support/lint_exclusions.txt +++ b/cpp/build-support/lint_exclusions.txt @@ -1,4 +1,5 @@ *_generated* +*.grpc.fb.* *parquet_constants.* *parquet_types.* *windows_compatibility.h diff --git a/cpp/build-support/update-flatbuffers.sh b/cpp/build-support/update-flatbuffers.sh index ac870ff12783e..b1116a1cbf703 100755 --- a/cpp/build-support/update-flatbuffers.sh +++ b/cpp/build-support/update-flatbuffers.sh @@ -20,22 +20,31 @@ # Run this from cpp/ directory. flatc is expected to be in your path +set -euo pipefail + CWD="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" -SOURCE_DIR=$CWD/../src -FORMAT_DIR=$CWD/../../format -FLATC="flatc -c --cpp-std c++11" - -$FLATC -o $SOURCE_DIR/generated \ - --scoped-enums \ - $FORMAT_DIR/Message.fbs \ - $FORMAT_DIR/File.fbs \ - $FORMAT_DIR/Schema.fbs \ - $FORMAT_DIR/Tensor.fbs \ - $FORMAT_DIR/SparseTensor.fbs \ - src/arrow/ipc/feather.fbs - -$FLATC -o $SOURCE_DIR/plasma \ - --gen-object-api \ - --scoped-enums \ - $SOURCE_DIR/plasma/common.fbs \ - $SOURCE_DIR/plasma/plasma.fbs +SOURCE_DIR="$CWD/../src" +PYTHON_SOURCE_DIR="$CWD/../../python" +FORMAT_DIR="$CWD/../../format" +TOP="$FORMAT_DIR/.." +FLATC="flatc" + +OUT_DIR="$SOURCE_DIR/generated" +FILES=($(find $FORMAT_DIR -name '*.fbs')) +FILES+=("$SOURCE_DIR/arrow/ipc/feather.fbs") + +# add compute ir files +FILES+=($(find "$TOP/experimental/computeir" -name '*.fbs')) + +$FLATC --cpp --cpp-std c++11 \ + --scoped-enums \ + -o "$OUT_DIR" \ + "${FILES[@]}" + +PLASMA_FBS=("$SOURCE_DIR"/plasma/{plasma,common}.fbs) + +$FLATC --cpp --cpp-std c++11 \ + -o "$SOURCE_DIR/plasma" \ + --gen-object-api \ + --scoped-enums \ + "${PLASMA_FBS[@]}" diff --git a/cpp/src/generated/Expression_generated.h b/cpp/src/generated/Expression_generated.h new file mode 100644 index 0000000000000..1a348c983b4fa --- /dev/null +++ b/cpp/src/generated/Expression_generated.h @@ -0,0 +1,1786 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_EXPRESSION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ +#define FLATBUFFERS_GENERATED_EXPRESSION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ + +#include "flatbuffers/flatbuffers.h" + +#include "Schema_generated.h" +#include "Literal_generated.h" + +namespace org { +namespace apache { +namespace arrow { +namespace computeir { +namespace flatbuf { + +struct MapKey; +struct MapKeyBuilder; + +struct StructField; +struct StructFieldBuilder; + +struct ArraySubscript; +struct ArraySubscriptBuilder; + +struct ArraySlice; +struct ArraySliceBuilder; + +struct FieldIndex; +struct FieldIndexBuilder; + +struct FieldRef; +struct FieldRefBuilder; + +struct Call; +struct CallBuilder; + +struct CaseFragment; +struct CaseFragmentBuilder; + +struct ConditionalCase; +struct ConditionalCaseBuilder; + +struct SimpleCase; +struct SimpleCaseBuilder; + +struct SortKey; +struct SortKeyBuilder; + +struct Unbounded; +struct UnboundedBuilder; + +struct Preceding; +struct PrecedingBuilder; + +struct Following; +struct FollowingBuilder; + +struct CurrentRow; +struct CurrentRowBuilder; + +struct WindowCall; +struct WindowCallBuilder; + +struct Expression; +struct ExpressionBuilder; + +/// A union of possible dereference operations +enum class Deref : uint8_t { + NONE = 0, + /// Access a value for a given map key + MapKey = 1, + /// Access the value at a struct field + StructField = 2, + /// Access the element at a given index in an array + ArraySubscript = 3, + /// Access a range of elements in an array + ArraySlice = 4, + /// Access a field of a relation + FieldIndex = 5, + MIN = NONE, + MAX = FieldIndex +}; + +inline const Deref (&EnumValuesDeref())[6] { + static const Deref values[] = { + Deref::NONE, + Deref::MapKey, + Deref::StructField, + Deref::ArraySubscript, + Deref::ArraySlice, + Deref::FieldIndex + }; + return values; +} + +inline const char * const *EnumNamesDeref() { + static const char * const names[7] = { + "NONE", + "MapKey", + "StructField", + "ArraySubscript", + "ArraySlice", + "FieldIndex", + nullptr + }; + return names; +} + +inline const char *EnumNameDeref(Deref e) { + if (flatbuffers::IsOutRange(e, Deref::NONE, Deref::FieldIndex)) return ""; + const size_t index = static_cast(e); + return EnumNamesDeref()[index]; +} + +template struct DerefTraits { + static const Deref enum_value = Deref::NONE; +}; + +template<> struct DerefTraits { + static const Deref enum_value = Deref::MapKey; +}; + +template<> struct DerefTraits { + static const Deref enum_value = Deref::StructField; +}; + +template<> struct DerefTraits { + static const Deref enum_value = Deref::ArraySubscript; +}; + +template<> struct DerefTraits { + static const Deref enum_value = Deref::ArraySlice; +}; + +template<> struct DerefTraits { + static const Deref enum_value = Deref::FieldIndex; +}; + +bool VerifyDeref(flatbuffers::Verifier &verifier, const void *obj, Deref type); +bool VerifyDerefVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +/// Whether lesser values should precede greater or vice versa, +/// also whether nulls should preced or follow values +enum class Ordering : uint8_t { + ASCENDING_THEN_NULLS = 0, + DESCENDING_THEN_NULLS = 1, + NULLS_THEN_ASCENDING = 2, + NULLS_THEN_DESCENDING = 3, + MIN = ASCENDING_THEN_NULLS, + MAX = NULLS_THEN_DESCENDING +}; + +inline const Ordering (&EnumValuesOrdering())[4] { + static const Ordering values[] = { + Ordering::ASCENDING_THEN_NULLS, + Ordering::DESCENDING_THEN_NULLS, + Ordering::NULLS_THEN_ASCENDING, + Ordering::NULLS_THEN_DESCENDING + }; + return values; +} + +inline const char * const *EnumNamesOrdering() { + static const char * const names[5] = { + "ASCENDING_THEN_NULLS", + "DESCENDING_THEN_NULLS", + "NULLS_THEN_ASCENDING", + "NULLS_THEN_DESCENDING", + nullptr + }; + return names; +} + +inline const char *EnumNameOrdering(Ordering e) { + if (flatbuffers::IsOutRange(e, Ordering::ASCENDING_THEN_NULLS, Ordering::NULLS_THEN_DESCENDING)) return ""; + const size_t index = static_cast(e); + return EnumNamesOrdering()[index]; +} + +/// A concrete bound, which can be an expression or unbounded +enum class ConcreteBoundImpl : uint8_t { + NONE = 0, + Expression = 1, + Unbounded = 2, + MIN = NONE, + MAX = Unbounded +}; + +inline const ConcreteBoundImpl (&EnumValuesConcreteBoundImpl())[3] { + static const ConcreteBoundImpl values[] = { + ConcreteBoundImpl::NONE, + ConcreteBoundImpl::Expression, + ConcreteBoundImpl::Unbounded + }; + return values; +} + +inline const char * const *EnumNamesConcreteBoundImpl() { + static const char * const names[4] = { + "NONE", + "Expression", + "Unbounded", + nullptr + }; + return names; +} + +inline const char *EnumNameConcreteBoundImpl(ConcreteBoundImpl e) { + if (flatbuffers::IsOutRange(e, ConcreteBoundImpl::NONE, ConcreteBoundImpl::Unbounded)) return ""; + const size_t index = static_cast(e); + return EnumNamesConcreteBoundImpl()[index]; +} + +template struct ConcreteBoundImplTraits { + static const ConcreteBoundImpl enum_value = ConcreteBoundImpl::NONE; +}; + +template<> struct ConcreteBoundImplTraits { + static const ConcreteBoundImpl enum_value = ConcreteBoundImpl::Expression; +}; + +template<> struct ConcreteBoundImplTraits { + static const ConcreteBoundImpl enum_value = ConcreteBoundImpl::Unbounded; +}; + +bool VerifyConcreteBoundImpl(flatbuffers::Verifier &verifier, const void *obj, ConcreteBoundImpl type); +bool VerifyConcreteBoundImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class Bound : uint8_t { + NONE = 0, + Preceding = 1, + Following = 2, + CurrentRow = 3, + MIN = NONE, + MAX = CurrentRow +}; + +inline const Bound (&EnumValuesBound())[4] { + static const Bound values[] = { + Bound::NONE, + Bound::Preceding, + Bound::Following, + Bound::CurrentRow + }; + return values; +} + +inline const char * const *EnumNamesBound() { + static const char * const names[5] = { + "NONE", + "Preceding", + "Following", + "CurrentRow", + nullptr + }; + return names; +} + +inline const char *EnumNameBound(Bound e) { + if (flatbuffers::IsOutRange(e, Bound::NONE, Bound::CurrentRow)) return ""; + const size_t index = static_cast(e); + return EnumNamesBound()[index]; +} + +template struct BoundTraits { + static const Bound enum_value = Bound::NONE; +}; + +template<> struct BoundTraits { + static const Bound enum_value = Bound::Preceding; +}; + +template<> struct BoundTraits { + static const Bound enum_value = Bound::Following; +}; + +template<> struct BoundTraits { + static const Bound enum_value = Bound::CurrentRow; +}; + +bool VerifyBound(flatbuffers::Verifier &verifier, const void *obj, Bound type); +bool VerifyBoundVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +/// The kind of window function to be executed +enum class Frame : uint8_t { + Rows = 0, + Range = 1, + MIN = Rows, + MAX = Range +}; + +inline const Frame (&EnumValuesFrame())[2] { + static const Frame values[] = { + Frame::Rows, + Frame::Range + }; + return values; +} + +inline const char * const *EnumNamesFrame() { + static const char * const names[3] = { + "Rows", + "Range", + nullptr + }; + return names; +} + +inline const char *EnumNameFrame(Frame e) { + if (flatbuffers::IsOutRange(e, Frame::Rows, Frame::Range)) return ""; + const size_t index = static_cast(e); + return EnumNamesFrame()[index]; +} + +/// Various expression types +/// +/// WindowCall is a separate variant +/// due to special options for each that don't apply to generic +/// function calls. Again this is done to make it easier +/// for consumers to deal with the structure of the operation +enum class ExpressionImpl : uint8_t { + NONE = 0, + Literal = 1, + FieldRef = 2, + Call = 3, + ConditionalCase = 4, + SimpleCase = 5, + WindowCall = 6, + MIN = NONE, + MAX = WindowCall +}; + +inline const ExpressionImpl (&EnumValuesExpressionImpl())[7] { + static const ExpressionImpl values[] = { + ExpressionImpl::NONE, + ExpressionImpl::Literal, + ExpressionImpl::FieldRef, + ExpressionImpl::Call, + ExpressionImpl::ConditionalCase, + ExpressionImpl::SimpleCase, + ExpressionImpl::WindowCall + }; + return values; +} + +inline const char * const *EnumNamesExpressionImpl() { + static const char * const names[8] = { + "NONE", + "Literal", + "FieldRef", + "Call", + "ConditionalCase", + "SimpleCase", + "WindowCall", + nullptr + }; + return names; +} + +inline const char *EnumNameExpressionImpl(ExpressionImpl e) { + if (flatbuffers::IsOutRange(e, ExpressionImpl::NONE, ExpressionImpl::WindowCall)) return ""; + const size_t index = static_cast(e); + return EnumNamesExpressionImpl()[index]; +} + +template struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::NONE; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::Literal; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::FieldRef; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::Call; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::ConditionalCase; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::SimpleCase; +}; + +template<> struct ExpressionImplTraits { + static const ExpressionImpl enum_value = ExpressionImpl::WindowCall; +}; + +bool VerifyExpressionImpl(flatbuffers::Verifier &verifier, const void *obj, ExpressionImpl type); +bool VerifyExpressionImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +/// Access a value for a given map key +struct MapKey FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MapKeyBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEY = 4 + }; + /// Any expression can be a map key. + const org::apache::arrow::computeir::flatbuf::Expression *key() const { + return GetPointer(VT_KEY); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_KEY) && + verifier.VerifyTable(key()) && + verifier.EndTable(); + } +}; + +struct MapKeyBuilder { + typedef MapKey Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_key(flatbuffers::Offset key) { + fbb_.AddOffset(MapKey::VT_KEY, key); + } + explicit MapKeyBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MapKeyBuilder &operator=(const MapKeyBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, MapKey::VT_KEY); + return o; + } +}; + +inline flatbuffers::Offset CreateMapKey( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset key = 0) { + MapKeyBuilder builder_(_fbb); + builder_.add_key(key); + return builder_.Finish(); +} + +/// Struct field access +struct StructField FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StructFieldBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POSITION = 4 + }; + /// The position of the field in the struct schema + uint32_t position() const { + return GetField(VT_POSITION, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POSITION) && + verifier.EndTable(); + } +}; + +struct StructFieldBuilder { + typedef StructField Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_position(uint32_t position) { + fbb_.AddElement(StructField::VT_POSITION, position, 0); + } + explicit StructFieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StructFieldBuilder &operator=(const StructFieldBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStructField( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t position = 0) { + StructFieldBuilder builder_(_fbb); + builder_.add_position(position); + return builder_.Finish(); +} + +/// Zero-based array index +struct ArraySubscript FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ArraySubscriptBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POSITION = 4 + }; + uint32_t position() const { + return GetField(VT_POSITION, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POSITION) && + verifier.EndTable(); + } +}; + +struct ArraySubscriptBuilder { + typedef ArraySubscript Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_position(uint32_t position) { + fbb_.AddElement(ArraySubscript::VT_POSITION, position, 0); + } + explicit ArraySubscriptBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ArraySubscriptBuilder &operator=(const ArraySubscriptBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateArraySubscript( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t position = 0) { + ArraySubscriptBuilder builder_(_fbb); + builder_.add_position(position); + return builder_.Finish(); +} + +/// Zero-based range of elements in an array +struct ArraySlice FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ArraySliceBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_START_INCLUSIVE = 4, + VT_END_EXCLUSIVE = 6 + }; + /// The start of an array slice, inclusive + uint32_t start_inclusive() const { + return GetField(VT_START_INCLUSIVE, 0); + } + /// The end of an array slice, exclusive + uint32_t end_exclusive() const { + return GetField(VT_END_EXCLUSIVE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_START_INCLUSIVE) && + VerifyField(verifier, VT_END_EXCLUSIVE) && + verifier.EndTable(); + } +}; + +struct ArraySliceBuilder { + typedef ArraySlice Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_start_inclusive(uint32_t start_inclusive) { + fbb_.AddElement(ArraySlice::VT_START_INCLUSIVE, start_inclusive, 0); + } + void add_end_exclusive(uint32_t end_exclusive) { + fbb_.AddElement(ArraySlice::VT_END_EXCLUSIVE, end_exclusive, 0); + } + explicit ArraySliceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ArraySliceBuilder &operator=(const ArraySliceBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateArraySlice( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t start_inclusive = 0, + uint32_t end_exclusive = 0) { + ArraySliceBuilder builder_(_fbb); + builder_.add_end_exclusive(end_exclusive); + builder_.add_start_inclusive(start_inclusive); + return builder_.Finish(); +} + +/// Field name in a relation, in ordinal position of the relation's schema. +struct FieldIndex FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FieldIndexBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POSITION = 4 + }; + uint32_t position() const { + return GetField(VT_POSITION, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POSITION) && + verifier.EndTable(); + } +}; + +struct FieldIndexBuilder { + typedef FieldIndex Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_position(uint32_t position) { + fbb_.AddElement(FieldIndex::VT_POSITION, position, 0); + } + explicit FieldIndexBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FieldIndexBuilder &operator=(const FieldIndexBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFieldIndex( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t position = 0) { + FieldIndexBuilder builder_(_fbb); + builder_.add_position(position); + return builder_.Finish(); +} + +/// Access the data of a field +struct FieldRef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FieldRefBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_REF_TYPE = 4, + VT_REF = 6, + VT_RELATION_INDEX = 8 + }; + org::apache::arrow::computeir::flatbuf::Deref ref_type() const { + return static_cast(GetField(VT_REF_TYPE, 0)); + } + const void *ref() const { + return GetPointer(VT_REF); + } + template const T *ref_as() const; + const org::apache::arrow::computeir::flatbuf::MapKey *ref_as_MapKey() const { + return ref_type() == org::apache::arrow::computeir::flatbuf::Deref::MapKey ? static_cast(ref()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::StructField *ref_as_StructField() const { + return ref_type() == org::apache::arrow::computeir::flatbuf::Deref::StructField ? static_cast(ref()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::ArraySubscript *ref_as_ArraySubscript() const { + return ref_type() == org::apache::arrow::computeir::flatbuf::Deref::ArraySubscript ? static_cast(ref()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::ArraySlice *ref_as_ArraySlice() const { + return ref_type() == org::apache::arrow::computeir::flatbuf::Deref::ArraySlice ? static_cast(ref()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::FieldIndex *ref_as_FieldIndex() const { + return ref_type() == org::apache::arrow::computeir::flatbuf::Deref::FieldIndex ? static_cast(ref()) : nullptr; + } + /// For Expressions which might reference fields in multiple Relations, + /// this index may be provided to indicate which Relation's fields + /// `ref` points into. For example in the case of a join, + /// 0 refers to the left relation and 1 to the right relation. + int32_t relation_index() const { + return GetField(VT_RELATION_INDEX, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_REF_TYPE) && + VerifyOffsetRequired(verifier, VT_REF) && + VerifyDeref(verifier, ref(), ref_type()) && + VerifyField(verifier, VT_RELATION_INDEX) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::MapKey *FieldRef::ref_as() const { + return ref_as_MapKey(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::StructField *FieldRef::ref_as() const { + return ref_as_StructField(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::ArraySubscript *FieldRef::ref_as() const { + return ref_as_ArraySubscript(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::ArraySlice *FieldRef::ref_as() const { + return ref_as_ArraySlice(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::FieldIndex *FieldRef::ref_as() const { + return ref_as_FieldIndex(); +} + +struct FieldRefBuilder { + typedef FieldRef Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_ref_type(org::apache::arrow::computeir::flatbuf::Deref ref_type) { + fbb_.AddElement(FieldRef::VT_REF_TYPE, static_cast(ref_type), 0); + } + void add_ref(flatbuffers::Offset ref) { + fbb_.AddOffset(FieldRef::VT_REF, ref); + } + void add_relation_index(int32_t relation_index) { + fbb_.AddElement(FieldRef::VT_RELATION_INDEX, relation_index, 0); + } + explicit FieldRefBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FieldRefBuilder &operator=(const FieldRefBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, FieldRef::VT_REF); + return o; + } +}; + +inline flatbuffers::Offset CreateFieldRef( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::Deref ref_type = org::apache::arrow::computeir::flatbuf::Deref::NONE, + flatbuffers::Offset ref = 0, + int32_t relation_index = 0) { + FieldRefBuilder builder_(_fbb); + builder_.add_relation_index(relation_index); + builder_.add_ref(ref); + builder_.add_ref_type(ref_type); + return builder_.Finish(); +} + +/// A function call expression +struct Call FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CallBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_ARGUMENTS = 6, + VT_ORDERINGS = 8 + }; + /// The function to call + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + /// The arguments passed to `name`. + const flatbuffers::Vector> *arguments() const { + return GetPointer> *>(VT_ARGUMENTS); + } + /// Possible ordering of input. These are useful + /// in aggregates where ordering in meaningful such as + /// string concatenation + const flatbuffers::Vector> *orderings() const { + return GetPointer> *>(VT_ORDERINGS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffsetRequired(verifier, VT_ARGUMENTS) && + verifier.VerifyVector(arguments()) && + verifier.VerifyVectorOfTables(arguments()) && + VerifyOffset(verifier, VT_ORDERINGS) && + verifier.VerifyVector(orderings()) && + verifier.VerifyVectorOfTables(orderings()) && + verifier.EndTable(); + } +}; + +struct CallBuilder { + typedef Call Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Call::VT_NAME, name); + } + void add_arguments(flatbuffers::Offset>> arguments) { + fbb_.AddOffset(Call::VT_ARGUMENTS, arguments); + } + void add_orderings(flatbuffers::Offset>> orderings) { + fbb_.AddOffset(Call::VT_ORDERINGS, orderings); + } + explicit CallBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CallBuilder &operator=(const CallBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Call::VT_NAME); + fbb_.Required(o, Call::VT_ARGUMENTS); + return o; + } +}; + +inline flatbuffers::Offset CreateCall( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset>> arguments = 0, + flatbuffers::Offset>> orderings = 0) { + CallBuilder builder_(_fbb); + builder_.add_orderings(orderings); + builder_.add_arguments(arguments); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateCallDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector> *arguments = nullptr, + const std::vector> *orderings = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto arguments__ = arguments ? _fbb.CreateVector>(*arguments) : 0; + auto orderings__ = orderings ? _fbb.CreateVector>(*orderings) : 0; + return org::apache::arrow::computeir::flatbuf::CreateCall( + _fbb, + name__, + arguments__, + orderings__); +} + +/// A single WHEN x THEN y fragment. +struct CaseFragment FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CaseFragmentBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MATCH = 4, + VT_RESULT = 6 + }; + const org::apache::arrow::computeir::flatbuf::Expression *match() const { + return GetPointer(VT_MATCH); + } + const org::apache::arrow::computeir::flatbuf::Expression *result() const { + return GetPointer(VT_RESULT); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_MATCH) && + verifier.VerifyTable(match()) && + VerifyOffsetRequired(verifier, VT_RESULT) && + verifier.VerifyTable(result()) && + verifier.EndTable(); + } +}; + +struct CaseFragmentBuilder { + typedef CaseFragment Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_match(flatbuffers::Offset match) { + fbb_.AddOffset(CaseFragment::VT_MATCH, match); + } + void add_result(flatbuffers::Offset result) { + fbb_.AddOffset(CaseFragment::VT_RESULT, result); + } + explicit CaseFragmentBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CaseFragmentBuilder &operator=(const CaseFragmentBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, CaseFragment::VT_MATCH); + fbb_.Required(o, CaseFragment::VT_RESULT); + return o; + } +}; + +inline flatbuffers::Offset CreateCaseFragment( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset match = 0, + flatbuffers::Offset result = 0) { + CaseFragmentBuilder builder_(_fbb); + builder_.add_result(result); + builder_.add_match(match); + return builder_.Finish(); +} + +/// Conditional case statement expression +struct ConditionalCase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConditionalCaseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CONDITIONS = 4, + VT_ELSE_ = 6 + }; + /// List of conditions to evaluate + const flatbuffers::Vector> *conditions() const { + return GetPointer> *>(VT_CONDITIONS); + } + /// The default value if no cases match. This is typically NULL in SQL + /// implementations. + /// + /// Defaulting to NULL is a frontend choice, so producers must specify NULL + /// if that's their desired behavior. + const org::apache::arrow::computeir::flatbuf::Expression *else_() const { + return GetPointer(VT_ELSE_); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_CONDITIONS) && + verifier.VerifyVector(conditions()) && + verifier.VerifyVectorOfTables(conditions()) && + VerifyOffsetRequired(verifier, VT_ELSE_) && + verifier.VerifyTable(else_()) && + verifier.EndTable(); + } +}; + +struct ConditionalCaseBuilder { + typedef ConditionalCase Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_conditions(flatbuffers::Offset>> conditions) { + fbb_.AddOffset(ConditionalCase::VT_CONDITIONS, conditions); + } + void add_else_(flatbuffers::Offset else_) { + fbb_.AddOffset(ConditionalCase::VT_ELSE_, else_); + } + explicit ConditionalCaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConditionalCaseBuilder &operator=(const ConditionalCaseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, ConditionalCase::VT_CONDITIONS); + fbb_.Required(o, ConditionalCase::VT_ELSE_); + return o; + } +}; + +inline flatbuffers::Offset CreateConditionalCase( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> conditions = 0, + flatbuffers::Offset else_ = 0) { + ConditionalCaseBuilder builder_(_fbb); + builder_.add_else_(else_); + builder_.add_conditions(conditions); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConditionalCaseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *conditions = nullptr, + flatbuffers::Offset else_ = 0) { + auto conditions__ = conditions ? _fbb.CreateVector>(*conditions) : 0; + return org::apache::arrow::computeir::flatbuf::CreateConditionalCase( + _fbb, + conditions__, + else_); +} + +/// Switch-style case expression +struct SimpleCase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SimpleCaseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EXPRESSION = 4, + VT_MATCHES = 6, + VT_ELSE_ = 8 + }; + /// The expression whose value will be matched + const org::apache::arrow::computeir::flatbuf::Expression *expression() const { + return GetPointer(VT_EXPRESSION); + } + /// Matches for `expression` + const flatbuffers::Vector> *matches() const { + return GetPointer> *>(VT_MATCHES); + } + /// The default value if no cases match + const org::apache::arrow::computeir::flatbuf::Expression *else_() const { + return GetPointer(VT_ELSE_); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_EXPRESSION) && + verifier.VerifyTable(expression()) && + VerifyOffsetRequired(verifier, VT_MATCHES) && + verifier.VerifyVector(matches()) && + verifier.VerifyVectorOfTables(matches()) && + VerifyOffsetRequired(verifier, VT_ELSE_) && + verifier.VerifyTable(else_()) && + verifier.EndTable(); + } +}; + +struct SimpleCaseBuilder { + typedef SimpleCase Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_expression(flatbuffers::Offset expression) { + fbb_.AddOffset(SimpleCase::VT_EXPRESSION, expression); + } + void add_matches(flatbuffers::Offset>> matches) { + fbb_.AddOffset(SimpleCase::VT_MATCHES, matches); + } + void add_else_(flatbuffers::Offset else_) { + fbb_.AddOffset(SimpleCase::VT_ELSE_, else_); + } + explicit SimpleCaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SimpleCaseBuilder &operator=(const SimpleCaseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, SimpleCase::VT_EXPRESSION); + fbb_.Required(o, SimpleCase::VT_MATCHES); + fbb_.Required(o, SimpleCase::VT_ELSE_); + return o; + } +}; + +inline flatbuffers::Offset CreateSimpleCase( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset expression = 0, + flatbuffers::Offset>> matches = 0, + flatbuffers::Offset else_ = 0) { + SimpleCaseBuilder builder_(_fbb); + builder_.add_else_(else_); + builder_.add_matches(matches); + builder_.add_expression(expression); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSimpleCaseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset expression = 0, + const std::vector> *matches = nullptr, + flatbuffers::Offset else_ = 0) { + auto matches__ = matches ? _fbb.CreateVector>(*matches) : 0; + return org::apache::arrow::computeir::flatbuf::CreateSimpleCase( + _fbb, + expression, + matches__, + else_); +} + +/// An expression with an order +struct SortKey FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SortKeyBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EXPRESSION = 4, + VT_ORDERING = 6 + }; + const org::apache::arrow::computeir::flatbuf::Expression *expression() const { + return GetPointer(VT_EXPRESSION); + } + org::apache::arrow::computeir::flatbuf::Ordering ordering() const { + return static_cast(GetField(VT_ORDERING, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_EXPRESSION) && + verifier.VerifyTable(expression()) && + VerifyField(verifier, VT_ORDERING) && + verifier.EndTable(); + } +}; + +struct SortKeyBuilder { + typedef SortKey Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_expression(flatbuffers::Offset expression) { + fbb_.AddOffset(SortKey::VT_EXPRESSION, expression); + } + void add_ordering(org::apache::arrow::computeir::flatbuf::Ordering ordering) { + fbb_.AddElement(SortKey::VT_ORDERING, static_cast(ordering), 0); + } + explicit SortKeyBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SortKeyBuilder &operator=(const SortKeyBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, SortKey::VT_EXPRESSION); + return o; + } +}; + +inline flatbuffers::Offset CreateSortKey( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset expression = 0, + org::apache::arrow::computeir::flatbuf::Ordering ordering = org::apache::arrow::computeir::flatbuf::Ordering::ASCENDING_THEN_NULLS) { + SortKeyBuilder builder_(_fbb); + builder_.add_expression(expression); + builder_.add_ordering(ordering); + return builder_.Finish(); +} + +/// An unbounded window bound +struct Unbounded FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UnboundedBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct UnboundedBuilder { + typedef Unbounded Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit UnboundedBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UnboundedBuilder &operator=(const UnboundedBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUnbounded( + flatbuffers::FlatBufferBuilder &_fbb) { + UnboundedBuilder builder_(_fbb); + return builder_.Finish(); +} + +/// Boundary is preceding rows, determined by the contained expression +struct Preceding FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PrecedingBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IMPL_TYPE = 4, + VT_IMPL = 6 + }; + org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type() const { + return static_cast(GetField(VT_IMPL_TYPE, 0)); + } + const void *impl() const { + return GetPointer(VT_IMPL); + } + template const T *impl_as() const; + const org::apache::arrow::computeir::flatbuf::Expression *impl_as_Expression() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::Expression ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Unbounded *impl_as_Unbounded() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::Unbounded ? static_cast(impl()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IMPL_TYPE) && + VerifyOffsetRequired(verifier, VT_IMPL) && + VerifyConcreteBoundImpl(verifier, impl(), impl_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Expression *Preceding::impl_as() const { + return impl_as_Expression(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Unbounded *Preceding::impl_as() const { + return impl_as_Unbounded(); +} + +struct PrecedingBuilder { + typedef Preceding Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_impl_type(org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type) { + fbb_.AddElement(Preceding::VT_IMPL_TYPE, static_cast(impl_type), 0); + } + void add_impl(flatbuffers::Offset impl) { + fbb_.AddOffset(Preceding::VT_IMPL, impl); + } + explicit PrecedingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PrecedingBuilder &operator=(const PrecedingBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Preceding::VT_IMPL); + return o; + } +}; + +inline flatbuffers::Offset CreatePreceding( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type = org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::NONE, + flatbuffers::Offset impl = 0) { + PrecedingBuilder builder_(_fbb); + builder_.add_impl(impl); + builder_.add_impl_type(impl_type); + return builder_.Finish(); +} + +/// Boundary is following rows, determined by the contained expression +struct Following FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FollowingBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IMPL_TYPE = 4, + VT_IMPL = 6 + }; + org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type() const { + return static_cast(GetField(VT_IMPL_TYPE, 0)); + } + const void *impl() const { + return GetPointer(VT_IMPL); + } + template const T *impl_as() const; + const org::apache::arrow::computeir::flatbuf::Expression *impl_as_Expression() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::Expression ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Unbounded *impl_as_Unbounded() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::Unbounded ? static_cast(impl()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IMPL_TYPE) && + VerifyOffsetRequired(verifier, VT_IMPL) && + VerifyConcreteBoundImpl(verifier, impl(), impl_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Expression *Following::impl_as() const { + return impl_as_Expression(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Unbounded *Following::impl_as() const { + return impl_as_Unbounded(); +} + +struct FollowingBuilder { + typedef Following Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_impl_type(org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type) { + fbb_.AddElement(Following::VT_IMPL_TYPE, static_cast(impl_type), 0); + } + void add_impl(flatbuffers::Offset impl) { + fbb_.AddOffset(Following::VT_IMPL, impl); + } + explicit FollowingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FollowingBuilder &operator=(const FollowingBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Following::VT_IMPL); + return o; + } +}; + +inline flatbuffers::Offset CreateFollowing( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl impl_type = org::apache::arrow::computeir::flatbuf::ConcreteBoundImpl::NONE, + flatbuffers::Offset impl = 0) { + FollowingBuilder builder_(_fbb); + builder_.add_impl(impl); + builder_.add_impl_type(impl_type); + return builder_.Finish(); +} + +/// Boundary is the current row +struct CurrentRow FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CurrentRowBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct CurrentRowBuilder { + typedef CurrentRow Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit CurrentRowBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CurrentRowBuilder &operator=(const CurrentRowBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateCurrentRow( + flatbuffers::FlatBufferBuilder &_fbb) { + CurrentRowBuilder builder_(_fbb); + return builder_.Finish(); +} + +/// An expression representing a window function call. +struct WindowCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef WindowCallBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EXPRESSION = 4, + VT_KIND = 6, + VT_PARTITIONS = 8, + VT_ORDERINGS = 10, + VT_LOWER_BOUND_TYPE = 12, + VT_LOWER_BOUND = 14, + VT_UPPER_BOUND_TYPE = 16, + VT_UPPER_BOUND = 18 + }; + /// The expression to operate over + const org::apache::arrow::computeir::flatbuf::Expression *expression() const { + return GetPointer(VT_EXPRESSION); + } + /// The kind of window frame + org::apache::arrow::computeir::flatbuf::Frame kind() const { + return static_cast(GetField(VT_KIND, 0)); + } + /// Partition keys + const flatbuffers::Vector> *partitions() const { + return GetPointer> *>(VT_PARTITIONS); + } + /// Sort keys + const flatbuffers::Vector> *orderings() const { + return GetPointer> *>(VT_ORDERINGS); + } + org::apache::arrow::computeir::flatbuf::Bound lower_bound_type() const { + return static_cast(GetField(VT_LOWER_BOUND_TYPE, 0)); + } + /// Lower window bound + const void *lower_bound() const { + return GetPointer(VT_LOWER_BOUND); + } + template const T *lower_bound_as() const; + const org::apache::arrow::computeir::flatbuf::Preceding *lower_bound_as_Preceding() const { + return lower_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::Preceding ? static_cast(lower_bound()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Following *lower_bound_as_Following() const { + return lower_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::Following ? static_cast(lower_bound()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::CurrentRow *lower_bound_as_CurrentRow() const { + return lower_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::CurrentRow ? static_cast(lower_bound()) : nullptr; + } + org::apache::arrow::computeir::flatbuf::Bound upper_bound_type() const { + return static_cast(GetField(VT_UPPER_BOUND_TYPE, 0)); + } + /// Upper window bound + const void *upper_bound() const { + return GetPointer(VT_UPPER_BOUND); + } + template const T *upper_bound_as() const; + const org::apache::arrow::computeir::flatbuf::Preceding *upper_bound_as_Preceding() const { + return upper_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::Preceding ? static_cast(upper_bound()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Following *upper_bound_as_Following() const { + return upper_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::Following ? static_cast(upper_bound()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::CurrentRow *upper_bound_as_CurrentRow() const { + return upper_bound_type() == org::apache::arrow::computeir::flatbuf::Bound::CurrentRow ? static_cast(upper_bound()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_EXPRESSION) && + verifier.VerifyTable(expression()) && + VerifyField(verifier, VT_KIND) && + VerifyOffsetRequired(verifier, VT_PARTITIONS) && + verifier.VerifyVector(partitions()) && + verifier.VerifyVectorOfTables(partitions()) && + VerifyOffsetRequired(verifier, VT_ORDERINGS) && + verifier.VerifyVector(orderings()) && + verifier.VerifyVectorOfTables(orderings()) && + VerifyField(verifier, VT_LOWER_BOUND_TYPE) && + VerifyOffsetRequired(verifier, VT_LOWER_BOUND) && + VerifyBound(verifier, lower_bound(), lower_bound_type()) && + VerifyField(verifier, VT_UPPER_BOUND_TYPE) && + VerifyOffsetRequired(verifier, VT_UPPER_BOUND) && + VerifyBound(verifier, upper_bound(), upper_bound_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Preceding *WindowCall::lower_bound_as() const { + return lower_bound_as_Preceding(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Following *WindowCall::lower_bound_as() const { + return lower_bound_as_Following(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::CurrentRow *WindowCall::lower_bound_as() const { + return lower_bound_as_CurrentRow(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Preceding *WindowCall::upper_bound_as() const { + return upper_bound_as_Preceding(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Following *WindowCall::upper_bound_as() const { + return upper_bound_as_Following(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::CurrentRow *WindowCall::upper_bound_as() const { + return upper_bound_as_CurrentRow(); +} + +struct WindowCallBuilder { + typedef WindowCall Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_expression(flatbuffers::Offset expression) { + fbb_.AddOffset(WindowCall::VT_EXPRESSION, expression); + } + void add_kind(org::apache::arrow::computeir::flatbuf::Frame kind) { + fbb_.AddElement(WindowCall::VT_KIND, static_cast(kind), 0); + } + void add_partitions(flatbuffers::Offset>> partitions) { + fbb_.AddOffset(WindowCall::VT_PARTITIONS, partitions); + } + void add_orderings(flatbuffers::Offset>> orderings) { + fbb_.AddOffset(WindowCall::VT_ORDERINGS, orderings); + } + void add_lower_bound_type(org::apache::arrow::computeir::flatbuf::Bound lower_bound_type) { + fbb_.AddElement(WindowCall::VT_LOWER_BOUND_TYPE, static_cast(lower_bound_type), 0); + } + void add_lower_bound(flatbuffers::Offset lower_bound) { + fbb_.AddOffset(WindowCall::VT_LOWER_BOUND, lower_bound); + } + void add_upper_bound_type(org::apache::arrow::computeir::flatbuf::Bound upper_bound_type) { + fbb_.AddElement(WindowCall::VT_UPPER_BOUND_TYPE, static_cast(upper_bound_type), 0); + } + void add_upper_bound(flatbuffers::Offset upper_bound) { + fbb_.AddOffset(WindowCall::VT_UPPER_BOUND, upper_bound); + } + explicit WindowCallBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + WindowCallBuilder &operator=(const WindowCallBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, WindowCall::VT_EXPRESSION); + fbb_.Required(o, WindowCall::VT_PARTITIONS); + fbb_.Required(o, WindowCall::VT_ORDERINGS); + fbb_.Required(o, WindowCall::VT_LOWER_BOUND); + fbb_.Required(o, WindowCall::VT_UPPER_BOUND); + return o; + } +}; + +inline flatbuffers::Offset CreateWindowCall( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset expression = 0, + org::apache::arrow::computeir::flatbuf::Frame kind = org::apache::arrow::computeir::flatbuf::Frame::Rows, + flatbuffers::Offset>> partitions = 0, + flatbuffers::Offset>> orderings = 0, + org::apache::arrow::computeir::flatbuf::Bound lower_bound_type = org::apache::arrow::computeir::flatbuf::Bound::NONE, + flatbuffers::Offset lower_bound = 0, + org::apache::arrow::computeir::flatbuf::Bound upper_bound_type = org::apache::arrow::computeir::flatbuf::Bound::NONE, + flatbuffers::Offset upper_bound = 0) { + WindowCallBuilder builder_(_fbb); + builder_.add_upper_bound(upper_bound); + builder_.add_lower_bound(lower_bound); + builder_.add_orderings(orderings); + builder_.add_partitions(partitions); + builder_.add_expression(expression); + builder_.add_upper_bound_type(upper_bound_type); + builder_.add_lower_bound_type(lower_bound_type); + builder_.add_kind(kind); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateWindowCallDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset expression = 0, + org::apache::arrow::computeir::flatbuf::Frame kind = org::apache::arrow::computeir::flatbuf::Frame::Rows, + const std::vector> *partitions = nullptr, + const std::vector> *orderings = nullptr, + org::apache::arrow::computeir::flatbuf::Bound lower_bound_type = org::apache::arrow::computeir::flatbuf::Bound::NONE, + flatbuffers::Offset lower_bound = 0, + org::apache::arrow::computeir::flatbuf::Bound upper_bound_type = org::apache::arrow::computeir::flatbuf::Bound::NONE, + flatbuffers::Offset upper_bound = 0) { + auto partitions__ = partitions ? _fbb.CreateVector>(*partitions) : 0; + auto orderings__ = orderings ? _fbb.CreateVector>(*orderings) : 0; + return org::apache::arrow::computeir::flatbuf::CreateWindowCall( + _fbb, + expression, + kind, + partitions__, + orderings__, + lower_bound_type, + lower_bound, + upper_bound_type, + upper_bound); +} + +/// Expression types +/// +/// Expressions have a concrete `impl` value, which is a specific operation. +/// +/// This is a workaround for flatbuffers' lack of support for direct use of +/// union types. +struct Expression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ExpressionBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IMPL_TYPE = 4, + VT_IMPL = 6 + }; + org::apache::arrow::computeir::flatbuf::ExpressionImpl impl_type() const { + return static_cast(GetField(VT_IMPL_TYPE, 0)); + } + const void *impl() const { + return GetPointer(VT_IMPL); + } + template const T *impl_as() const; + const org::apache::arrow::computeir::flatbuf::Literal *impl_as_Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::FieldRef *impl_as_FieldRef() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::FieldRef ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Call *impl_as_Call() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::Call ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::ConditionalCase *impl_as_ConditionalCase() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::ConditionalCase ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::SimpleCase *impl_as_SimpleCase() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::SimpleCase ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::WindowCall *impl_as_WindowCall() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::ExpressionImpl::WindowCall ? static_cast(impl()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IMPL_TYPE) && + VerifyOffsetRequired(verifier, VT_IMPL) && + VerifyExpressionImpl(verifier, impl(), impl_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Literal *Expression::impl_as() const { + return impl_as_Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::FieldRef *Expression::impl_as() const { + return impl_as_FieldRef(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Call *Expression::impl_as() const { + return impl_as_Call(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::ConditionalCase *Expression::impl_as() const { + return impl_as_ConditionalCase(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::SimpleCase *Expression::impl_as() const { + return impl_as_SimpleCase(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::WindowCall *Expression::impl_as() const { + return impl_as_WindowCall(); +} + +struct ExpressionBuilder { + typedef Expression Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_impl_type(org::apache::arrow::computeir::flatbuf::ExpressionImpl impl_type) { + fbb_.AddElement(Expression::VT_IMPL_TYPE, static_cast(impl_type), 0); + } + void add_impl(flatbuffers::Offset impl) { + fbb_.AddOffset(Expression::VT_IMPL, impl); + } + explicit ExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ExpressionBuilder &operator=(const ExpressionBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Expression::VT_IMPL); + return o; + } +}; + +inline flatbuffers::Offset CreateExpression( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::ExpressionImpl impl_type = org::apache::arrow::computeir::flatbuf::ExpressionImpl::NONE, + flatbuffers::Offset impl = 0) { + ExpressionBuilder builder_(_fbb); + builder_.add_impl(impl); + builder_.add_impl_type(impl_type); + return builder_.Finish(); +} + +inline bool VerifyDeref(flatbuffers::Verifier &verifier, const void *obj, Deref type) { + switch (type) { + case Deref::NONE: { + return true; + } + case Deref::MapKey: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Deref::StructField: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Deref::ArraySubscript: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Deref::ArraySlice: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Deref::FieldIndex: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyDerefVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyDeref( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyConcreteBoundImpl(flatbuffers::Verifier &verifier, const void *obj, ConcreteBoundImpl type) { + switch (type) { + case ConcreteBoundImpl::NONE: { + return true; + } + case ConcreteBoundImpl::Expression: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ConcreteBoundImpl::Unbounded: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyConcreteBoundImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyConcreteBoundImpl( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyBound(flatbuffers::Verifier &verifier, const void *obj, Bound type) { + switch (type) { + case Bound::NONE: { + return true; + } + case Bound::Preceding: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Bound::Following: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Bound::CurrentRow: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyBoundVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyBound( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyExpressionImpl(flatbuffers::Verifier &verifier, const void *obj, ExpressionImpl type) { + switch (type) { + case ExpressionImpl::NONE: { + return true; + } + case ExpressionImpl::Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExpressionImpl::FieldRef: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExpressionImpl::Call: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExpressionImpl::ConditionalCase: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExpressionImpl::SimpleCase: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExpressionImpl::WindowCall: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyExpressionImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyExpressionImpl( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const org::apache::arrow::computeir::flatbuf::Expression *GetExpression(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const org::apache::arrow::computeir::flatbuf::Expression *GetSizePrefixedExpression(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyExpressionBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedExpressionBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishExpressionBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedExpressionBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace flatbuf +} // namespace computeir +} // namespace arrow +} // namespace apache +} // namespace org + +#endif // FLATBUFFERS_GENERATED_EXPRESSION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h index fe6578e538c46..06953c4a04044 100644 --- a/cpp/src/generated/File_generated.h +++ b/cpp/src/generated/File_generated.h @@ -14,6 +14,7 @@ namespace arrow { namespace flatbuf { struct Footer; +struct FooterBuilder; struct Block; @@ -55,6 +56,7 @@ FLATBUFFERS_STRUCT_END(Block, 24); /// Arrow File metadata /// struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FooterBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VERSION = 4, VT_SCHEMA = 6, @@ -95,6 +97,7 @@ struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct FooterBuilder { + typedef Footer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_version(org::apache::arrow::flatbuf::MetadataVersion version) { diff --git a/cpp/src/generated/Literal_generated.h b/cpp/src/generated/Literal_generated.h new file mode 100644 index 0000000000000..f7be482942dfb --- /dev/null +++ b/cpp/src/generated/Literal_generated.h @@ -0,0 +1,2243 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_LITERAL_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ +#define FLATBUFFERS_GENERATED_LITERAL_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ + +#include "flatbuffers/flatbuffers.h" + +#include "Schema_generated.h" + +namespace org { +namespace apache { +namespace arrow { +namespace computeir { +namespace flatbuf { + +struct ListLiteral; +struct ListLiteralBuilder; + +struct StructLiteralField; +struct StructLiteralFieldBuilder; + +struct StructLiteral; +struct StructLiteralBuilder; + +struct KeyValue; +struct KeyValueBuilder; + +struct MapLiteral; +struct MapLiteralBuilder; + +struct Int8Literal; +struct Int8LiteralBuilder; + +struct Int16Literal; +struct Int16LiteralBuilder; + +struct Int32Literal; +struct Int32LiteralBuilder; + +struct Int64Literal; +struct Int64LiteralBuilder; + +struct UInt8Literal; +struct UInt8LiteralBuilder; + +struct UInt16Literal; +struct UInt16LiteralBuilder; + +struct UInt32Literal; +struct UInt32LiteralBuilder; + +struct UInt64Literal; +struct UInt64LiteralBuilder; + +struct Float16Literal; +struct Float16LiteralBuilder; + +struct Float32Literal; +struct Float32LiteralBuilder; + +struct Float64Literal; +struct Float64LiteralBuilder; + +struct DecimalLiteral; +struct DecimalLiteralBuilder; + +struct BooleanLiteral; +struct BooleanLiteralBuilder; + +struct NullLiteral; +struct NullLiteralBuilder; + +struct DateLiteral; +struct DateLiteralBuilder; + +struct TimeLiteral; +struct TimeLiteralBuilder; + +struct TimestampLiteral; +struct TimestampLiteralBuilder; + +struct IntervalLiteralMonths; +struct IntervalLiteralMonthsBuilder; + +struct IntervalLiteralDaysMilliseconds; +struct IntervalLiteralDaysMillisecondsBuilder; + +struct IntervalLiteral; +struct IntervalLiteralBuilder; + +struct DurationLiteral; +struct DurationLiteralBuilder; + +struct BinaryLiteral; +struct BinaryLiteralBuilder; + +struct FixedSizeBinaryLiteral; +struct FixedSizeBinaryLiteralBuilder; + +struct StringLiteral; +struct StringLiteralBuilder; + +struct Literal; +struct LiteralBuilder; + +enum class IntervalLiteralImpl : uint8_t { + NONE = 0, + IntervalLiteralMonths = 1, + IntervalLiteralDaysMilliseconds = 2, + MIN = NONE, + MAX = IntervalLiteralDaysMilliseconds +}; + +inline const IntervalLiteralImpl (&EnumValuesIntervalLiteralImpl())[3] { + static const IntervalLiteralImpl values[] = { + IntervalLiteralImpl::NONE, + IntervalLiteralImpl::IntervalLiteralMonths, + IntervalLiteralImpl::IntervalLiteralDaysMilliseconds + }; + return values; +} + +inline const char * const *EnumNamesIntervalLiteralImpl() { + static const char * const names[4] = { + "NONE", + "IntervalLiteralMonths", + "IntervalLiteralDaysMilliseconds", + nullptr + }; + return names; +} + +inline const char *EnumNameIntervalLiteralImpl(IntervalLiteralImpl e) { + if (flatbuffers::IsOutRange(e, IntervalLiteralImpl::NONE, IntervalLiteralImpl::IntervalLiteralDaysMilliseconds)) return ""; + const size_t index = static_cast(e); + return EnumNamesIntervalLiteralImpl()[index]; +} + +template struct IntervalLiteralImplTraits { + static const IntervalLiteralImpl enum_value = IntervalLiteralImpl::NONE; +}; + +template<> struct IntervalLiteralImplTraits { + static const IntervalLiteralImpl enum_value = IntervalLiteralImpl::IntervalLiteralMonths; +}; + +template<> struct IntervalLiteralImplTraits { + static const IntervalLiteralImpl enum_value = IntervalLiteralImpl::IntervalLiteralDaysMilliseconds; +}; + +bool VerifyIntervalLiteralImpl(flatbuffers::Verifier &verifier, const void *obj, IntervalLiteralImpl type); +bool VerifyIntervalLiteralImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class LiteralImpl : uint8_t { + NONE = 0, + NullLiteral = 1, + BooleanLiteral = 2, + Int8Literal = 3, + Int16Literal = 4, + Int32Literal = 5, + Int64Literal = 6, + UInt8Literal = 7, + UInt16Literal = 8, + UInt32Literal = 9, + UInt64Literal = 10, + DateLiteral = 11, + TimeLiteral = 12, + TimestampLiteral = 13, + IntervalLiteral = 14, + DurationLiteral = 15, + DecimalLiteral = 16, + Float16Literal = 17, + Float32Literal = 18, + Float64Literal = 19, + ListLiteral = 20, + StructLiteral = 21, + MapLiteral = 22, + StringLiteral = 23, + BinaryLiteral = 24, + FixedSizeBinaryLiteral = 25, + MIN = NONE, + MAX = FixedSizeBinaryLiteral +}; + +inline const LiteralImpl (&EnumValuesLiteralImpl())[26] { + static const LiteralImpl values[] = { + LiteralImpl::NONE, + LiteralImpl::NullLiteral, + LiteralImpl::BooleanLiteral, + LiteralImpl::Int8Literal, + LiteralImpl::Int16Literal, + LiteralImpl::Int32Literal, + LiteralImpl::Int64Literal, + LiteralImpl::UInt8Literal, + LiteralImpl::UInt16Literal, + LiteralImpl::UInt32Literal, + LiteralImpl::UInt64Literal, + LiteralImpl::DateLiteral, + LiteralImpl::TimeLiteral, + LiteralImpl::TimestampLiteral, + LiteralImpl::IntervalLiteral, + LiteralImpl::DurationLiteral, + LiteralImpl::DecimalLiteral, + LiteralImpl::Float16Literal, + LiteralImpl::Float32Literal, + LiteralImpl::Float64Literal, + LiteralImpl::ListLiteral, + LiteralImpl::StructLiteral, + LiteralImpl::MapLiteral, + LiteralImpl::StringLiteral, + LiteralImpl::BinaryLiteral, + LiteralImpl::FixedSizeBinaryLiteral + }; + return values; +} + +inline const char * const *EnumNamesLiteralImpl() { + static const char * const names[27] = { + "NONE", + "NullLiteral", + "BooleanLiteral", + "Int8Literal", + "Int16Literal", + "Int32Literal", + "Int64Literal", + "UInt8Literal", + "UInt16Literal", + "UInt32Literal", + "UInt64Literal", + "DateLiteral", + "TimeLiteral", + "TimestampLiteral", + "IntervalLiteral", + "DurationLiteral", + "DecimalLiteral", + "Float16Literal", + "Float32Literal", + "Float64Literal", + "ListLiteral", + "StructLiteral", + "MapLiteral", + "StringLiteral", + "BinaryLiteral", + "FixedSizeBinaryLiteral", + nullptr + }; + return names; +} + +inline const char *EnumNameLiteralImpl(LiteralImpl e) { + if (flatbuffers::IsOutRange(e, LiteralImpl::NONE, LiteralImpl::FixedSizeBinaryLiteral)) return ""; + const size_t index = static_cast(e); + return EnumNamesLiteralImpl()[index]; +} + +template struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::NONE; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::NullLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::BooleanLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Int8Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Int16Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Int32Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Int64Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::UInt8Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::UInt16Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::UInt32Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::UInt64Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::DateLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::TimeLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::TimestampLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::IntervalLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::DurationLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::DecimalLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Float16Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Float32Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::Float64Literal; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::ListLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::StructLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::MapLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::StringLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::BinaryLiteral; +}; + +template<> struct LiteralImplTraits { + static const LiteralImpl enum_value = LiteralImpl::FixedSizeBinaryLiteral; +}; + +bool VerifyLiteralImpl(flatbuffers::Verifier &verifier, const void *obj, LiteralImpl type); +bool VerifyLiteralImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +struct ListLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ListLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUES = 4 + }; + const flatbuffers::Vector> *values() const { + return GetPointer> *>(VT_VALUES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUES) && + verifier.VerifyVector(values()) && + verifier.VerifyVectorOfTables(values()) && + verifier.EndTable(); + } +}; + +struct ListLiteralBuilder { + typedef ListLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_values(flatbuffers::Offset>> values) { + fbb_.AddOffset(ListLiteral::VT_VALUES, values); + } + explicit ListLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ListLiteralBuilder &operator=(const ListLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, ListLiteral::VT_VALUES); + return o; + } +}; + +inline flatbuffers::Offset CreateListLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> values = 0) { + ListLiteralBuilder builder_(_fbb); + builder_.add_values(values); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateListLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *values = nullptr) { + auto values__ = values ? _fbb.CreateVector>(*values) : 0; + return org::apache::arrow::computeir::flatbuf::CreateListLiteral( + _fbb, + values__); +} + +struct StructLiteralField FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StructLiteralFieldBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_VALUE = 6 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const org::apache::arrow::computeir::flatbuf::Literal *value() const { + return GetPointer(VT_VALUE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyTable(value()) && + verifier.EndTable(); + } +}; + +struct StructLiteralFieldBuilder { + typedef StructLiteralField Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(StructLiteralField::VT_NAME, name); + } + void add_value(flatbuffers::Offset value) { + fbb_.AddOffset(StructLiteralField::VT_VALUE, value); + } + explicit StructLiteralFieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StructLiteralFieldBuilder &operator=(const StructLiteralFieldBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, StructLiteralField::VT_NAME); + fbb_.Required(o, StructLiteralField::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateStructLiteralField( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset value = 0) { + StructLiteralFieldBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStructLiteralFieldDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + flatbuffers::Offset value = 0) { + auto name__ = name ? _fbb.CreateString(name) : 0; + return org::apache::arrow::computeir::flatbuf::CreateStructLiteralField( + _fbb, + name__, + value); +} + +struct StructLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StructLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUES = 4 + }; + const flatbuffers::Vector> *values() const { + return GetPointer> *>(VT_VALUES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUES) && + verifier.VerifyVector(values()) && + verifier.VerifyVectorOfTables(values()) && + verifier.EndTable(); + } +}; + +struct StructLiteralBuilder { + typedef StructLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_values(flatbuffers::Offset>> values) { + fbb_.AddOffset(StructLiteral::VT_VALUES, values); + } + explicit StructLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StructLiteralBuilder &operator=(const StructLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, StructLiteral::VT_VALUES); + return o; + } +}; + +inline flatbuffers::Offset CreateStructLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> values = 0) { + StructLiteralBuilder builder_(_fbb); + builder_.add_values(values); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStructLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *values = nullptr) { + auto values__ = values ? _fbb.CreateVector>(*values) : 0; + return org::apache::arrow::computeir::flatbuf::CreateStructLiteral( + _fbb, + values__); +} + +struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeyValueBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEY = 4, + VT_VALUE = 6 + }; + const org::apache::arrow::computeir::flatbuf::Literal *key() const { + return GetPointer(VT_KEY); + } + const org::apache::arrow::computeir::flatbuf::Literal *value() const { + return GetPointer(VT_VALUE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_KEY) && + verifier.VerifyTable(key()) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyTable(value()) && + verifier.EndTable(); + } +}; + +struct KeyValueBuilder { + typedef KeyValue Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_key(flatbuffers::Offset key) { + fbb_.AddOffset(KeyValue::VT_KEY, key); + } + void add_value(flatbuffers::Offset value) { + fbb_.AddOffset(KeyValue::VT_VALUE, value); + } + explicit KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + KeyValueBuilder &operator=(const KeyValueBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, KeyValue::VT_KEY); + fbb_.Required(o, KeyValue::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateKeyValue( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset key = 0, + flatbuffers::Offset value = 0) { + KeyValueBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_key(key); + return builder_.Finish(); +} + +struct MapLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MapLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUES = 4 + }; + const flatbuffers::Vector> *values() const { + return GetPointer> *>(VT_VALUES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUES) && + verifier.VerifyVector(values()) && + verifier.VerifyVectorOfTables(values()) && + verifier.EndTable(); + } +}; + +struct MapLiteralBuilder { + typedef MapLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_values(flatbuffers::Offset>> values) { + fbb_.AddOffset(MapLiteral::VT_VALUES, values); + } + explicit MapLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MapLiteralBuilder &operator=(const MapLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, MapLiteral::VT_VALUES); + return o; + } +}; + +inline flatbuffers::Offset CreateMapLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> values = 0) { + MapLiteralBuilder builder_(_fbb); + builder_.add_values(values); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateMapLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *values = nullptr) { + auto values__ = values ? _fbb.CreateVector>(*values) : 0; + return org::apache::arrow::computeir::flatbuf::CreateMapLiteral( + _fbb, + values__); +} + +struct Int8Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Int8LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + int8_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Int8LiteralBuilder { + typedef Int8Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int8_t value) { + fbb_.AddElement(Int8Literal::VT_VALUE, value, 0); + } + explicit Int8LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Int8LiteralBuilder &operator=(const Int8LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInt8Literal( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t value = 0) { + Int8LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Int16Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Int16LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + int16_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Int16LiteralBuilder { + typedef Int16Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int16_t value) { + fbb_.AddElement(Int16Literal::VT_VALUE, value, 0); + } + explicit Int16LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Int16LiteralBuilder &operator=(const Int16LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInt16Literal( + flatbuffers::FlatBufferBuilder &_fbb, + int16_t value = 0) { + Int16LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Int32Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Int32LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + int32_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Int32LiteralBuilder { + typedef Int32Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int32_t value) { + fbb_.AddElement(Int32Literal::VT_VALUE, value, 0); + } + explicit Int32LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Int32LiteralBuilder &operator=(const Int32LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInt32Literal( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t value = 0) { + Int32LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Int64Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Int64LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + int64_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Int64LiteralBuilder { + typedef Int64Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int64_t value) { + fbb_.AddElement(Int64Literal::VT_VALUE, value, 0); + } + explicit Int64LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Int64LiteralBuilder &operator=(const Int64LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInt64Literal( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0) { + Int64LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct UInt8Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UInt8LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + uint8_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct UInt8LiteralBuilder { + typedef UInt8Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(uint8_t value) { + fbb_.AddElement(UInt8Literal::VT_VALUE, value, 0); + } + explicit UInt8LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UInt8LiteralBuilder &operator=(const UInt8LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUInt8Literal( + flatbuffers::FlatBufferBuilder &_fbb, + uint8_t value = 0) { + UInt8LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct UInt16Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UInt16LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + uint16_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct UInt16LiteralBuilder { + typedef UInt16Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(uint16_t value) { + fbb_.AddElement(UInt16Literal::VT_VALUE, value, 0); + } + explicit UInt16LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UInt16LiteralBuilder &operator=(const UInt16LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUInt16Literal( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t value = 0) { + UInt16LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct UInt32Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UInt32LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + uint32_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct UInt32LiteralBuilder { + typedef UInt32Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(uint32_t value) { + fbb_.AddElement(UInt32Literal::VT_VALUE, value, 0); + } + explicit UInt32LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UInt32LiteralBuilder &operator=(const UInt32LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUInt32Literal( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t value = 0) { + UInt32LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct UInt64Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UInt64LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + uint64_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct UInt64LiteralBuilder { + typedef UInt64Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(uint64_t value) { + fbb_.AddElement(UInt64Literal::VT_VALUE, value, 0); + } + explicit UInt64LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UInt64LiteralBuilder &operator=(const UInt64LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUInt64Literal( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t value = 0) { + UInt64LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Float16Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Float16LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + uint16_t value() const { + return GetField(VT_VALUE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Float16LiteralBuilder { + typedef Float16Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(uint16_t value) { + fbb_.AddElement(Float16Literal::VT_VALUE, value, 0); + } + explicit Float16LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Float16LiteralBuilder &operator=(const Float16LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFloat16Literal( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t value = 0) { + Float16LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Float32Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Float32LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + float value() const { + return GetField(VT_VALUE, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Float32LiteralBuilder { + typedef Float32Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(float value) { + fbb_.AddElement(Float32Literal::VT_VALUE, value, 0.0f); + } + explicit Float32LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Float32LiteralBuilder &operator=(const Float32LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFloat32Literal( + flatbuffers::FlatBufferBuilder &_fbb, + float value = 0.0f) { + Float32LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct Float64Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Float64LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + double value() const { + return GetField(VT_VALUE, 0.0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct Float64LiteralBuilder { + typedef Float64Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(double value) { + fbb_.AddElement(Float64Literal::VT_VALUE, value, 0.0); + } + explicit Float64LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Float64LiteralBuilder &operator=(const Float64LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFloat64Literal( + flatbuffers::FlatBufferBuilder &_fbb, + double value = 0.0) { + Float64LiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct DecimalLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DecimalLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_SCALE = 6, + VT_PRECISION = 8 + }; + /// These bytes must be in little-endian order. + const flatbuffers::Vector *value() const { + return GetPointer *>(VT_VALUE); + } + int32_t scale() const { + return GetField(VT_SCALE, 0); + } + int32_t precision() const { + return GetField(VT_PRECISION, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyVector(value()) && + VerifyField(verifier, VT_SCALE) && + VerifyField(verifier, VT_PRECISION) && + verifier.EndTable(); + } +}; + +struct DecimalLiteralBuilder { + typedef DecimalLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(flatbuffers::Offset> value) { + fbb_.AddOffset(DecimalLiteral::VT_VALUE, value); + } + void add_scale(int32_t scale) { + fbb_.AddElement(DecimalLiteral::VT_SCALE, scale, 0); + } + void add_precision(int32_t precision) { + fbb_.AddElement(DecimalLiteral::VT_PRECISION, precision, 0); + } + explicit DecimalLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DecimalLiteralBuilder &operator=(const DecimalLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, DecimalLiteral::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateDecimalLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> value = 0, + int32_t scale = 0, + int32_t precision = 0) { + DecimalLiteralBuilder builder_(_fbb); + builder_.add_precision(precision); + builder_.add_scale(scale); + builder_.add_value(value); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateDecimalLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *value = nullptr, + int32_t scale = 0, + int32_t precision = 0) { + auto value__ = value ? _fbb.CreateVector(*value) : 0; + return org::apache::arrow::computeir::flatbuf::CreateDecimalLiteral( + _fbb, + value__, + scale, + precision); +} + +struct BooleanLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BooleanLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + bool value() const { + return GetField(VT_VALUE, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct BooleanLiteralBuilder { + typedef BooleanLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(bool value) { + fbb_.AddElement(BooleanLiteral::VT_VALUE, static_cast(value), 0); + } + explicit BooleanLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BooleanLiteralBuilder &operator=(const BooleanLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBooleanLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + bool value = false) { + BooleanLiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct NullLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NullLiteralBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct NullLiteralBuilder { + typedef NullLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit NullLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NullLiteralBuilder &operator=(const NullLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNullLiteral( + flatbuffers::FlatBufferBuilder &_fbb) { + NullLiteralBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct DateLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DateLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_UNIT = 6 + }; + int64_t value() const { + return GetField(VT_VALUE, 0); + } + org::apache::arrow::flatbuf::DateUnit unit() const { + return static_cast(GetField(VT_UNIT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + VerifyField(verifier, VT_UNIT) && + verifier.EndTable(); + } +}; + +struct DateLiteralBuilder { + typedef DateLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int64_t value) { + fbb_.AddElement(DateLiteral::VT_VALUE, value, 0); + } + void add_unit(org::apache::arrow::flatbuf::DateUnit unit) { + fbb_.AddElement(DateLiteral::VT_UNIT, static_cast(unit), 1); + } + explicit DateLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DateLiteralBuilder &operator=(const DateLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDateLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0, + org::apache::arrow::flatbuf::DateUnit unit = org::apache::arrow::flatbuf::DateUnit::MILLISECOND) { + DateLiteralBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_unit(unit); + return builder_.Finish(); +} + +struct TimeLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TimeLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_UNIT = 6 + }; + int64_t value() const { + return GetField(VT_VALUE, 0); + } + org::apache::arrow::flatbuf::TimeUnit unit() const { + return static_cast(GetField(VT_UNIT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + VerifyField(verifier, VT_UNIT) && + verifier.EndTable(); + } +}; + +struct TimeLiteralBuilder { + typedef TimeLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int64_t value) { + fbb_.AddElement(TimeLiteral::VT_VALUE, value, 0); + } + void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) { + fbb_.AddElement(TimeLiteral::VT_UNIT, static_cast(unit), 1); + } + explicit TimeLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TimeLiteralBuilder &operator=(const TimeLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTimeLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0, + org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::MILLISECOND) { + TimeLiteralBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_unit(unit); + return builder_.Finish(); +} + +struct TimestampLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TimestampLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_UNIT = 6, + VT_TIMEZONE = 8 + }; + int64_t value() const { + return GetField(VT_VALUE, 0); + } + org::apache::arrow::flatbuf::TimeUnit unit() const { + return static_cast(GetField(VT_UNIT, 0)); + } + const flatbuffers::String *timezone() const { + return GetPointer(VT_TIMEZONE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + VerifyField(verifier, VT_UNIT) && + VerifyOffset(verifier, VT_TIMEZONE) && + verifier.VerifyString(timezone()) && + verifier.EndTable(); + } +}; + +struct TimestampLiteralBuilder { + typedef TimestampLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int64_t value) { + fbb_.AddElement(TimestampLiteral::VT_VALUE, value, 0); + } + void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) { + fbb_.AddElement(TimestampLiteral::VT_UNIT, static_cast(unit), 0); + } + void add_timezone(flatbuffers::Offset timezone) { + fbb_.AddOffset(TimestampLiteral::VT_TIMEZONE, timezone); + } + explicit TimestampLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TimestampLiteralBuilder &operator=(const TimestampLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTimestampLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0, + org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::SECOND, + flatbuffers::Offset timezone = 0) { + TimestampLiteralBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_timezone(timezone); + builder_.add_unit(unit); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTimestampLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0, + org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::SECOND, + const char *timezone = nullptr) { + auto timezone__ = timezone ? _fbb.CreateString(timezone) : 0; + return org::apache::arrow::computeir::flatbuf::CreateTimestampLiteral( + _fbb, + value, + unit, + timezone__); +} + +struct IntervalLiteralMonths FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IntervalLiteralMonthsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MONTHS = 4 + }; + int32_t months() const { + return GetField(VT_MONTHS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_MONTHS) && + verifier.EndTable(); + } +}; + +struct IntervalLiteralMonthsBuilder { + typedef IntervalLiteralMonths Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_months(int32_t months) { + fbb_.AddElement(IntervalLiteralMonths::VT_MONTHS, months, 0); + } + explicit IntervalLiteralMonthsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + IntervalLiteralMonthsBuilder &operator=(const IntervalLiteralMonthsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateIntervalLiteralMonths( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t months = 0) { + IntervalLiteralMonthsBuilder builder_(_fbb); + builder_.add_months(months); + return builder_.Finish(); +} + +struct IntervalLiteralDaysMilliseconds FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IntervalLiteralDaysMillisecondsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DAYS = 4, + VT_MILLISECONDS = 6 + }; + int32_t days() const { + return GetField(VT_DAYS, 0); + } + int32_t milliseconds() const { + return GetField(VT_MILLISECONDS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DAYS) && + VerifyField(verifier, VT_MILLISECONDS) && + verifier.EndTable(); + } +}; + +struct IntervalLiteralDaysMillisecondsBuilder { + typedef IntervalLiteralDaysMilliseconds Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_days(int32_t days) { + fbb_.AddElement(IntervalLiteralDaysMilliseconds::VT_DAYS, days, 0); + } + void add_milliseconds(int32_t milliseconds) { + fbb_.AddElement(IntervalLiteralDaysMilliseconds::VT_MILLISECONDS, milliseconds, 0); + } + explicit IntervalLiteralDaysMillisecondsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + IntervalLiteralDaysMillisecondsBuilder &operator=(const IntervalLiteralDaysMillisecondsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateIntervalLiteralDaysMilliseconds( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t days = 0, + int32_t milliseconds = 0) { + IntervalLiteralDaysMillisecondsBuilder builder_(_fbb); + builder_.add_milliseconds(milliseconds); + builder_.add_days(days); + return builder_.Finish(); +} + +struct IntervalLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IntervalLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE_TYPE = 4, + VT_VALUE = 6 + }; + org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl value_type() const { + return static_cast(GetField(VT_VALUE_TYPE, 0)); + } + const void *value() const { + return GetPointer(VT_VALUE); + } + template const T *value_as() const; + const org::apache::arrow::computeir::flatbuf::IntervalLiteralMonths *value_as_IntervalLiteralMonths() const { + return value_type() == org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl::IntervalLiteralMonths ? static_cast(value()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::IntervalLiteralDaysMilliseconds *value_as_IntervalLiteralDaysMilliseconds() const { + return value_type() == org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl::IntervalLiteralDaysMilliseconds ? static_cast(value()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE_TYPE) && + VerifyOffsetRequired(verifier, VT_VALUE) && + VerifyIntervalLiteralImpl(verifier, value(), value_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::IntervalLiteralMonths *IntervalLiteral::value_as() const { + return value_as_IntervalLiteralMonths(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::IntervalLiteralDaysMilliseconds *IntervalLiteral::value_as() const { + return value_as_IntervalLiteralDaysMilliseconds(); +} + +struct IntervalLiteralBuilder { + typedef IntervalLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value_type(org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl value_type) { + fbb_.AddElement(IntervalLiteral::VT_VALUE_TYPE, static_cast(value_type), 0); + } + void add_value(flatbuffers::Offset value) { + fbb_.AddOffset(IntervalLiteral::VT_VALUE, value); + } + explicit IntervalLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + IntervalLiteralBuilder &operator=(const IntervalLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, IntervalLiteral::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateIntervalLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl value_type = org::apache::arrow::computeir::flatbuf::IntervalLiteralImpl::NONE, + flatbuffers::Offset value = 0) { + IntervalLiteralBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_value_type(value_type); + return builder_.Finish(); +} + +struct DurationLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DurationLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_UNIT = 6 + }; + int64_t value() const { + return GetField(VT_VALUE, 0); + } + org::apache::arrow::flatbuf::TimeUnit unit() const { + return static_cast(GetField(VT_UNIT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + VerifyField(verifier, VT_UNIT) && + verifier.EndTable(); + } +}; + +struct DurationLiteralBuilder { + typedef DurationLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(int64_t value) { + fbb_.AddElement(DurationLiteral::VT_VALUE, value, 0); + } + void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) { + fbb_.AddElement(DurationLiteral::VT_UNIT, static_cast(unit), 1); + } + explicit DurationLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DurationLiteralBuilder &operator=(const DurationLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDurationLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t value = 0, + org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::MILLISECOND) { + DurationLiteralBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_unit(unit); + return builder_.Finish(); +} + +struct BinaryLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BinaryLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + const flatbuffers::Vector *value() const { + return GetPointer *>(VT_VALUE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyVector(value()) && + verifier.EndTable(); + } +}; + +struct BinaryLiteralBuilder { + typedef BinaryLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(flatbuffers::Offset> value) { + fbb_.AddOffset(BinaryLiteral::VT_VALUE, value); + } + explicit BinaryLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BinaryLiteralBuilder &operator=(const BinaryLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, BinaryLiteral::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateBinaryLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> value = 0) { + BinaryLiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateBinaryLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *value = nullptr) { + auto value__ = value ? _fbb.CreateVector(*value) : 0; + return org::apache::arrow::computeir::flatbuf::CreateBinaryLiteral( + _fbb, + value__); +} + +struct FixedSizeBinaryLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FixedSizeBinaryLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4, + VT_SIZE = 6 + }; + const flatbuffers::Vector *value() const { + return GetPointer *>(VT_VALUE); + } + int32_t size() const { + return GetField(VT_SIZE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyVector(value()) && + VerifyField(verifier, VT_SIZE) && + verifier.EndTable(); + } +}; + +struct FixedSizeBinaryLiteralBuilder { + typedef FixedSizeBinaryLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(flatbuffers::Offset> value) { + fbb_.AddOffset(FixedSizeBinaryLiteral::VT_VALUE, value); + } + void add_size(int32_t size) { + fbb_.AddElement(FixedSizeBinaryLiteral::VT_SIZE, size, 0); + } + explicit FixedSizeBinaryLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FixedSizeBinaryLiteralBuilder &operator=(const FixedSizeBinaryLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, FixedSizeBinaryLiteral::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateFixedSizeBinaryLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> value = 0, + int32_t size = 0) { + FixedSizeBinaryLiteralBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_value(value); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateFixedSizeBinaryLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *value = nullptr, + int32_t size = 0) { + auto value__ = value ? _fbb.CreateVector(*value) : 0; + return org::apache::arrow::computeir::flatbuf::CreateFixedSizeBinaryLiteral( + _fbb, + value__, + size); +} + +struct StringLiteral FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StringLiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + const flatbuffers::String *value() const { + return GetPointer(VT_VALUE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_VALUE) && + verifier.VerifyString(value()) && + verifier.EndTable(); + } +}; + +struct StringLiteralBuilder { + typedef StringLiteral Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(flatbuffers::Offset value) { + fbb_.AddOffset(StringLiteral::VT_VALUE, value); + } + explicit StringLiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StringLiteralBuilder &operator=(const StringLiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, StringLiteral::VT_VALUE); + return o; + } +}; + +inline flatbuffers::Offset CreateStringLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset value = 0) { + StringLiteralBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStringLiteralDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *value = nullptr) { + auto value__ = value ? _fbb.CreateString(value) : 0; + return org::apache::arrow::computeir::flatbuf::CreateStringLiteral( + _fbb, + value__); +} + +struct Literal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LiteralBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IMPL_TYPE = 4, + VT_IMPL = 6 + }; + org::apache::arrow::computeir::flatbuf::LiteralImpl impl_type() const { + return static_cast(GetField(VT_IMPL_TYPE, 0)); + } + const void *impl() const { + return GetPointer(VT_IMPL); + } + template const T *impl_as() const; + const org::apache::arrow::computeir::flatbuf::NullLiteral *impl_as_NullLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::NullLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::BooleanLiteral *impl_as_BooleanLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::BooleanLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Int8Literal *impl_as_Int8Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Int8Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Int16Literal *impl_as_Int16Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Int16Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Int32Literal *impl_as_Int32Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Int32Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Int64Literal *impl_as_Int64Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Int64Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::UInt8Literal *impl_as_UInt8Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::UInt8Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::UInt16Literal *impl_as_UInt16Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::UInt16Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::UInt32Literal *impl_as_UInt32Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::UInt32Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::UInt64Literal *impl_as_UInt64Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::UInt64Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::DateLiteral *impl_as_DateLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::DateLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::TimeLiteral *impl_as_TimeLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::TimeLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::TimestampLiteral *impl_as_TimestampLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::TimestampLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::IntervalLiteral *impl_as_IntervalLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::IntervalLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::DurationLiteral *impl_as_DurationLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::DurationLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::DecimalLiteral *impl_as_DecimalLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::DecimalLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Float16Literal *impl_as_Float16Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Float16Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Float32Literal *impl_as_Float32Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Float32Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Float64Literal *impl_as_Float64Literal() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::Float64Literal ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::ListLiteral *impl_as_ListLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::ListLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::StructLiteral *impl_as_StructLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::StructLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::MapLiteral *impl_as_MapLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::MapLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::StringLiteral *impl_as_StringLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::StringLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::BinaryLiteral *impl_as_BinaryLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::BinaryLiteral ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::FixedSizeBinaryLiteral *impl_as_FixedSizeBinaryLiteral() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::LiteralImpl::FixedSizeBinaryLiteral ? static_cast(impl()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IMPL_TYPE) && + VerifyOffsetRequired(verifier, VT_IMPL) && + VerifyLiteralImpl(verifier, impl(), impl_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::NullLiteral *Literal::impl_as() const { + return impl_as_NullLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::BooleanLiteral *Literal::impl_as() const { + return impl_as_BooleanLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Int8Literal *Literal::impl_as() const { + return impl_as_Int8Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Int16Literal *Literal::impl_as() const { + return impl_as_Int16Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Int32Literal *Literal::impl_as() const { + return impl_as_Int32Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Int64Literal *Literal::impl_as() const { + return impl_as_Int64Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::UInt8Literal *Literal::impl_as() const { + return impl_as_UInt8Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::UInt16Literal *Literal::impl_as() const { + return impl_as_UInt16Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::UInt32Literal *Literal::impl_as() const { + return impl_as_UInt32Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::UInt64Literal *Literal::impl_as() const { + return impl_as_UInt64Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::DateLiteral *Literal::impl_as() const { + return impl_as_DateLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::TimeLiteral *Literal::impl_as() const { + return impl_as_TimeLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::TimestampLiteral *Literal::impl_as() const { + return impl_as_TimestampLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::IntervalLiteral *Literal::impl_as() const { + return impl_as_IntervalLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::DurationLiteral *Literal::impl_as() const { + return impl_as_DurationLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::DecimalLiteral *Literal::impl_as() const { + return impl_as_DecimalLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Float16Literal *Literal::impl_as() const { + return impl_as_Float16Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Float32Literal *Literal::impl_as() const { + return impl_as_Float32Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Float64Literal *Literal::impl_as() const { + return impl_as_Float64Literal(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::ListLiteral *Literal::impl_as() const { + return impl_as_ListLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::StructLiteral *Literal::impl_as() const { + return impl_as_StructLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::MapLiteral *Literal::impl_as() const { + return impl_as_MapLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::StringLiteral *Literal::impl_as() const { + return impl_as_StringLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::BinaryLiteral *Literal::impl_as() const { + return impl_as_BinaryLiteral(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::FixedSizeBinaryLiteral *Literal::impl_as() const { + return impl_as_FixedSizeBinaryLiteral(); +} + +struct LiteralBuilder { + typedef Literal Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_impl_type(org::apache::arrow::computeir::flatbuf::LiteralImpl impl_type) { + fbb_.AddElement(Literal::VT_IMPL_TYPE, static_cast(impl_type), 0); + } + void add_impl(flatbuffers::Offset impl) { + fbb_.AddOffset(Literal::VT_IMPL, impl); + } + explicit LiteralBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LiteralBuilder &operator=(const LiteralBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Literal::VT_IMPL); + return o; + } +}; + +inline flatbuffers::Offset CreateLiteral( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::LiteralImpl impl_type = org::apache::arrow::computeir::flatbuf::LiteralImpl::NONE, + flatbuffers::Offset impl = 0) { + LiteralBuilder builder_(_fbb); + builder_.add_impl(impl); + builder_.add_impl_type(impl_type); + return builder_.Finish(); +} + +inline bool VerifyIntervalLiteralImpl(flatbuffers::Verifier &verifier, const void *obj, IntervalLiteralImpl type) { + switch (type) { + case IntervalLiteralImpl::NONE: { + return true; + } + case IntervalLiteralImpl::IntervalLiteralMonths: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case IntervalLiteralImpl::IntervalLiteralDaysMilliseconds: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyIntervalLiteralImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyIntervalLiteralImpl( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyLiteralImpl(flatbuffers::Verifier &verifier, const void *obj, LiteralImpl type) { + switch (type) { + case LiteralImpl::NONE: { + return true; + } + case LiteralImpl::NullLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::BooleanLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Int8Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Int16Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Int32Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Int64Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::UInt8Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::UInt16Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::UInt32Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::UInt64Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::DateLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::TimeLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::TimestampLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::IntervalLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::DurationLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::DecimalLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Float16Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Float32Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::Float64Literal: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::ListLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::StructLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::MapLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::StringLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::BinaryLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case LiteralImpl::FixedSizeBinaryLiteral: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyLiteralImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyLiteralImpl( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const org::apache::arrow::computeir::flatbuf::Literal *GetLiteral(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const org::apache::arrow::computeir::flatbuf::Literal *GetSizePrefixedLiteral(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyLiteralBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedLiteralBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishLiteralBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedLiteralBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace flatbuf +} // namespace computeir +} // namespace arrow +} // namespace apache +} // namespace org + +#endif // FLATBUFFERS_GENERATED_LITERAL_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ diff --git a/cpp/src/generated/Message_generated.h b/cpp/src/generated/Message_generated.h index b08dcfd210c6b..1c51c6eafb3b7 100644 --- a/cpp/src/generated/Message_generated.h +++ b/cpp/src/generated/Message_generated.h @@ -18,12 +18,16 @@ namespace flatbuf { struct FieldNode; struct BodyCompression; +struct BodyCompressionBuilder; struct RecordBatch; +struct RecordBatchBuilder; struct DictionaryBatch; +struct DictionaryBatchBuilder; struct Message; +struct MessageBuilder; enum class CompressionType : int8_t { LZ4_FRAME = 0, @@ -209,6 +213,7 @@ FLATBUFFERS_STRUCT_END(FieldNode, 16); /// bodies. Intended for use with RecordBatch but could be used for other /// message types struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BodyCompressionBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_CODEC = 4, VT_METHOD = 6 @@ -230,6 +235,7 @@ struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct BodyCompressionBuilder { + typedef BodyCompression Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_codec(org::apache::arrow::flatbuf::CompressionType codec) { @@ -264,6 +270,7 @@ inline flatbuffers::Offset CreateBodyCompression( /// batch. Some systems call this a "row batch" internally and others a "record /// batch". struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RecordBatchBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_LENGTH = 4, VT_NODES = 6, @@ -306,6 +313,7 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct RecordBatchBuilder { + typedef RecordBatch Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_length(int64_t length) { @@ -369,6 +377,7 @@ inline flatbuffers::Offset CreateRecordBatchDirect( /// may be spread across multiple dictionary batches by using the isDelta /// flag struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DictionaryBatchBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_DATA = 6, @@ -397,6 +406,7 @@ struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct DictionaryBatchBuilder { + typedef DictionaryBatch Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_id(int64_t id) { @@ -433,6 +443,7 @@ inline flatbuffers::Offset CreateDictionaryBatch( } struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MessageBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VERSION = 4, VT_HEADER_TYPE = 6, @@ -506,6 +517,7 @@ template<> inline const org::apache::arrow::flatbuf::SparseTensor *Message::head } struct MessageBuilder { + typedef Message Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_version(org::apache::arrow::flatbuf::MetadataVersion version) { diff --git a/cpp/src/generated/Plan_generated.h b/cpp/src/generated/Plan_generated.h new file mode 100644 index 0000000000000..33f02af58a07f --- /dev/null +++ b/cpp/src/generated/Plan_generated.h @@ -0,0 +1,115 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_PLAN_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ +#define FLATBUFFERS_GENERATED_PLAN_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ + +#include "flatbuffers/flatbuffers.h" + +#include "Schema_generated.h" +#include "Expression_generated.h" +#include "Literal_generated.h" +#include "Relation_generated.h" + +namespace org { +namespace apache { +namespace arrow { +namespace computeir { +namespace flatbuf { + +struct Plan; +struct PlanBuilder; + +/// A specification of a query. +struct Plan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PlanBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SINKS = 4 + }; + /// One or more output relations. + const flatbuffers::Vector> *sinks() const { + return GetPointer> *>(VT_SINKS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_SINKS) && + verifier.VerifyVector(sinks()) && + verifier.VerifyVectorOfTables(sinks()) && + verifier.EndTable(); + } +}; + +struct PlanBuilder { + typedef Plan Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_sinks(flatbuffers::Offset>> sinks) { + fbb_.AddOffset(Plan::VT_SINKS, sinks); + } + explicit PlanBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PlanBuilder &operator=(const PlanBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Plan::VT_SINKS); + return o; + } +}; + +inline flatbuffers::Offset CreatePlan( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> sinks = 0) { + PlanBuilder builder_(_fbb); + builder_.add_sinks(sinks); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePlanDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *sinks = nullptr) { + auto sinks__ = sinks ? _fbb.CreateVector>(*sinks) : 0; + return org::apache::arrow::computeir::flatbuf::CreatePlan( + _fbb, + sinks__); +} + +inline const org::apache::arrow::computeir::flatbuf::Plan *GetPlan(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const org::apache::arrow::computeir::flatbuf::Plan *GetSizePrefixedPlan(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyPlanBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedPlanBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishPlanBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedPlanBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace flatbuf +} // namespace computeir +} // namespace arrow +} // namespace apache +} // namespace org + +#endif // FLATBUFFERS_GENERATED_PLAN_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ diff --git a/cpp/src/generated/Relation_generated.h b/cpp/src/generated/Relation_generated.h new file mode 100644 index 0000000000000..25bc93476117e --- /dev/null +++ b/cpp/src/generated/Relation_generated.h @@ -0,0 +1,1568 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ +#define FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ + +#include "flatbuffers/flatbuffers.h" + +#include "Schema_generated.h" +#include "Expression_generated.h" +#include "Literal_generated.h" + +namespace org { +namespace apache { +namespace arrow { +namespace computeir { +namespace flatbuf { + +struct Remap; +struct RemapBuilder; + +struct PassThrough; +struct PassThroughBuilder; + +struct RelBase; +struct RelBaseBuilder; + +struct Filter; +struct FilterBuilder; + +struct Project; +struct ProjectBuilder; + +struct Grouping; +struct GroupingBuilder; + +struct Aggregate; +struct AggregateBuilder; + +struct Join; +struct JoinBuilder; + +struct OrderBy; +struct OrderByBuilder; + +struct Limit; +struct LimitBuilder; + +struct SetOperation; +struct SetOperationBuilder; + +struct LiteralColumn; +struct LiteralColumnBuilder; + +struct LiteralRelation; +struct LiteralRelationBuilder; + +struct Table; +struct TableBuilder; + +struct Relation; +struct RelationBuilder; + +/// A union for the different colum remapping variants +enum class Emit : uint8_t { + NONE = 0, + Remap = 1, + PassThrough = 2, + MIN = NONE, + MAX = PassThrough +}; + +inline const Emit (&EnumValuesEmit())[3] { + static const Emit values[] = { + Emit::NONE, + Emit::Remap, + Emit::PassThrough + }; + return values; +} + +inline const char * const *EnumNamesEmit() { + static const char * const names[4] = { + "NONE", + "Remap", + "PassThrough", + nullptr + }; + return names; +} + +inline const char *EnumNameEmit(Emit e) { + if (flatbuffers::IsOutRange(e, Emit::NONE, Emit::PassThrough)) return ""; + const size_t index = static_cast(e); + return EnumNamesEmit()[index]; +} + +template struct EmitTraits { + static const Emit enum_value = Emit::NONE; +}; + +template<> struct EmitTraits { + static const Emit enum_value = Emit::Remap; +}; + +template<> struct EmitTraits { + static const Emit enum_value = Emit::PassThrough; +}; + +bool VerifyEmit(flatbuffers::Verifier &verifier, const void *obj, Emit type); +bool VerifyEmitVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class JoinKind : uint8_t { + Anti = 0, + Cross = 1, + FullOuter = 2, + Inner = 3, + LeftOuter = 4, + LeftSemi = 5, + RightOuter = 6, + MIN = Anti, + MAX = RightOuter +}; + +inline const JoinKind (&EnumValuesJoinKind())[7] { + static const JoinKind values[] = { + JoinKind::Anti, + JoinKind::Cross, + JoinKind::FullOuter, + JoinKind::Inner, + JoinKind::LeftOuter, + JoinKind::LeftSemi, + JoinKind::RightOuter + }; + return values; +} + +inline const char * const *EnumNamesJoinKind() { + static const char * const names[8] = { + "Anti", + "Cross", + "FullOuter", + "Inner", + "LeftOuter", + "LeftSemi", + "RightOuter", + nullptr + }; + return names; +} + +inline const char *EnumNameJoinKind(JoinKind e) { + if (flatbuffers::IsOutRange(e, JoinKind::Anti, JoinKind::RightOuter)) return ""; + const size_t index = static_cast(e); + return EnumNamesJoinKind()[index]; +} + +/// The kind of set operation being performed. +enum class SetOpKind : uint8_t { + Union = 0, + Intersection = 1, + Difference = 2, + MIN = Union, + MAX = Difference +}; + +inline const SetOpKind (&EnumValuesSetOpKind())[3] { + static const SetOpKind values[] = { + SetOpKind::Union, + SetOpKind::Intersection, + SetOpKind::Difference + }; + return values; +} + +inline const char * const *EnumNamesSetOpKind() { + static const char * const names[4] = { + "Union", + "Intersection", + "Difference", + nullptr + }; + return names; +} + +inline const char *EnumNameSetOpKind(SetOpKind e) { + if (flatbuffers::IsOutRange(e, SetOpKind::Union, SetOpKind::Difference)) return ""; + const size_t index = static_cast(e); + return EnumNamesSetOpKind()[index]; +} + +/// The varieties of relations +enum class RelationImpl : uint8_t { + NONE = 0, + Aggregate = 1, + SetOperation = 2, + Filter = 3, + Limit = 4, + LiteralRelation = 5, + OrderBy = 6, + Project = 7, + Table = 8, + MIN = NONE, + MAX = Table +}; + +inline const RelationImpl (&EnumValuesRelationImpl())[9] { + static const RelationImpl values[] = { + RelationImpl::NONE, + RelationImpl::Aggregate, + RelationImpl::SetOperation, + RelationImpl::Filter, + RelationImpl::Limit, + RelationImpl::LiteralRelation, + RelationImpl::OrderBy, + RelationImpl::Project, + RelationImpl::Table + }; + return values; +} + +inline const char * const *EnumNamesRelationImpl() { + static const char * const names[10] = { + "NONE", + "Aggregate", + "SetOperation", + "Filter", + "Limit", + "LiteralRelation", + "OrderBy", + "Project", + "Table", + nullptr + }; + return names; +} + +inline const char *EnumNameRelationImpl(RelationImpl e) { + if (flatbuffers::IsOutRange(e, RelationImpl::NONE, RelationImpl::Table)) return ""; + const size_t index = static_cast(e); + return EnumNamesRelationImpl()[index]; +} + +template struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::NONE; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::Aggregate; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::SetOperation; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::Filter; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::Limit; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::LiteralRelation; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::OrderBy; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::Project; +}; + +template<> struct RelationImplTraits { + static const RelationImpl enum_value = RelationImpl::Table; +}; + +bool VerifyRelationImpl(flatbuffers::Verifier &verifier, const void *obj, RelationImpl type); +bool VerifyRelationImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +/// A data type indicating that a different mapping of columns +/// should occur in the output. +/// +/// For example: +/// +/// Given a query `SELECT b, a FROM t` where `t` has columns a, b, c +/// the mapping value for the projection would equal [1, 0]. +struct Remap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RemapBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MAPPING = 4 + }; + const flatbuffers::Vector> *mapping() const { + return GetPointer> *>(VT_MAPPING); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_MAPPING) && + verifier.VerifyVector(mapping()) && + verifier.VerifyVectorOfTables(mapping()) && + verifier.EndTable(); + } +}; + +struct RemapBuilder { + typedef Remap Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_mapping(flatbuffers::Offset>> mapping) { + fbb_.AddOffset(Remap::VT_MAPPING, mapping); + } + explicit RemapBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RemapBuilder &operator=(const RemapBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Remap::VT_MAPPING); + return o; + } +}; + +inline flatbuffers::Offset CreateRemap( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> mapping = 0) { + RemapBuilder builder_(_fbb); + builder_.add_mapping(mapping); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateRemapDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *mapping = nullptr) { + auto mapping__ = mapping ? _fbb.CreateVector>(*mapping) : 0; + return org::apache::arrow::computeir::flatbuf::CreateRemap( + _fbb, + mapping__); +} + +struct PassThrough FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PassThroughBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct PassThroughBuilder { + typedef PassThrough Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit PassThroughBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PassThroughBuilder &operator=(const PassThroughBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePassThrough( + flatbuffers::FlatBufferBuilder &_fbb) { + PassThroughBuilder builder_(_fbb); + return builder_.Finish(); +} + +/// Fields common to every relational operator +struct RelBase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RelBaseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OUTPUT_MAPPING_TYPE = 4, + VT_OUTPUT_MAPPING = 6 + }; + org::apache::arrow::computeir::flatbuf::Emit output_mapping_type() const { + return static_cast(GetField(VT_OUTPUT_MAPPING_TYPE, 0)); + } + /// Output remapping of ordinal columns for a given operation + const void *output_mapping() const { + return GetPointer(VT_OUTPUT_MAPPING); + } + template const T *output_mapping_as() const; + const org::apache::arrow::computeir::flatbuf::Remap *output_mapping_as_Remap() const { + return output_mapping_type() == org::apache::arrow::computeir::flatbuf::Emit::Remap ? static_cast(output_mapping()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::PassThrough *output_mapping_as_PassThrough() const { + return output_mapping_type() == org::apache::arrow::computeir::flatbuf::Emit::PassThrough ? static_cast(output_mapping()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_OUTPUT_MAPPING_TYPE) && + VerifyOffsetRequired(verifier, VT_OUTPUT_MAPPING) && + VerifyEmit(verifier, output_mapping(), output_mapping_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Remap *RelBase::output_mapping_as() const { + return output_mapping_as_Remap(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::PassThrough *RelBase::output_mapping_as() const { + return output_mapping_as_PassThrough(); +} + +struct RelBaseBuilder { + typedef RelBase Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_output_mapping_type(org::apache::arrow::computeir::flatbuf::Emit output_mapping_type) { + fbb_.AddElement(RelBase::VT_OUTPUT_MAPPING_TYPE, static_cast(output_mapping_type), 0); + } + void add_output_mapping(flatbuffers::Offset output_mapping) { + fbb_.AddOffset(RelBase::VT_OUTPUT_MAPPING, output_mapping); + } + explicit RelBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RelBaseBuilder &operator=(const RelBaseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, RelBase::VT_OUTPUT_MAPPING); + return o; + } +}; + +inline flatbuffers::Offset CreateRelBase( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::Emit output_mapping_type = org::apache::arrow::computeir::flatbuf::Emit::NONE, + flatbuffers::Offset output_mapping = 0) { + RelBaseBuilder builder_(_fbb); + builder_.add_output_mapping(output_mapping); + builder_.add_output_mapping_type(output_mapping_type); + return builder_.Finish(); +} + +/// Filter operation +struct Filter FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FilterBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REL = 6, + VT_PREDICATE = 8 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relation + const org::apache::arrow::computeir::flatbuf::Relation *rel() const { + return GetPointer(VT_REL); + } + /// The expression which will be evaluated against input rows + /// to determine whether they should be excluded from the + /// filter relation's output. + const org::apache::arrow::computeir::flatbuf::Expression *predicate() const { + return GetPointer(VT_PREDICATE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_REL) && + verifier.VerifyTable(rel()) && + VerifyOffsetRequired(verifier, VT_PREDICATE) && + verifier.VerifyTable(predicate()) && + verifier.EndTable(); + } +}; + +struct FilterBuilder { + typedef Filter Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Filter::VT_BASE, base); + } + void add_rel(flatbuffers::Offset rel) { + fbb_.AddOffset(Filter::VT_REL, rel); + } + void add_predicate(flatbuffers::Offset predicate) { + fbb_.AddOffset(Filter::VT_PREDICATE, predicate); + } + explicit FilterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FilterBuilder &operator=(const FilterBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Filter::VT_BASE); + fbb_.Required(o, Filter::VT_REL); + fbb_.Required(o, Filter::VT_PREDICATE); + return o; + } +}; + +inline flatbuffers::Offset CreateFilter( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + flatbuffers::Offset predicate = 0) { + FilterBuilder builder_(_fbb); + builder_.add_predicate(predicate); + builder_.add_rel(rel); + builder_.add_base(base); + return builder_.Finish(); +} + +/// Projection +struct Project FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ProjectBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REL = 6, + VT_EXPRESSIONS = 8 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relation + const org::apache::arrow::computeir::flatbuf::Relation *rel() const { + return GetPointer(VT_REL); + } + /// Expressions which will be evaluated to produce to + /// the rows of the project relation's output. + const flatbuffers::Vector> *expressions() const { + return GetPointer> *>(VT_EXPRESSIONS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_REL) && + verifier.VerifyTable(rel()) && + VerifyOffsetRequired(verifier, VT_EXPRESSIONS) && + verifier.VerifyVector(expressions()) && + verifier.VerifyVectorOfTables(expressions()) && + verifier.EndTable(); + } +}; + +struct ProjectBuilder { + typedef Project Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Project::VT_BASE, base); + } + void add_rel(flatbuffers::Offset rel) { + fbb_.AddOffset(Project::VT_REL, rel); + } + void add_expressions(flatbuffers::Offset>> expressions) { + fbb_.AddOffset(Project::VT_EXPRESSIONS, expressions); + } + explicit ProjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ProjectBuilder &operator=(const ProjectBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Project::VT_BASE); + fbb_.Required(o, Project::VT_REL); + fbb_.Required(o, Project::VT_EXPRESSIONS); + return o; + } +}; + +inline flatbuffers::Offset CreateProject( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + flatbuffers::Offset>> expressions = 0) { + ProjectBuilder builder_(_fbb); + builder_.add_expressions(expressions); + builder_.add_rel(rel); + builder_.add_base(base); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateProjectDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + const std::vector> *expressions = nullptr) { + auto expressions__ = expressions ? _fbb.CreateVector>(*expressions) : 0; + return org::apache::arrow::computeir::flatbuf::CreateProject( + _fbb, + base, + rel, + expressions__); +} + +/// A set of grouping keys +struct Grouping FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GroupingBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYS = 4 + }; + /// Expressions to group by + const flatbuffers::Vector> *keys() const { + return GetPointer> *>(VT_KEYS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_KEYS) && + verifier.VerifyVector(keys()) && + verifier.VerifyVectorOfTables(keys()) && + verifier.EndTable(); + } +}; + +struct GroupingBuilder { + typedef Grouping Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keys(flatbuffers::Offset>> keys) { + fbb_.AddOffset(Grouping::VT_KEYS, keys); + } + explicit GroupingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + GroupingBuilder &operator=(const GroupingBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Grouping::VT_KEYS); + return o; + } +}; + +inline flatbuffers::Offset CreateGrouping( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> keys = 0) { + GroupingBuilder builder_(_fbb); + builder_.add_keys(keys); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateGroupingDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *keys = nullptr) { + auto keys__ = keys ? _fbb.CreateVector>(*keys) : 0; + return org::apache::arrow::computeir::flatbuf::CreateGrouping( + _fbb, + keys__); +} + +/// Aggregate operation +struct Aggregate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AggregateBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REL = 6, + VT_MEASURES = 8, + VT_GROUPINGS = 10 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relation + const org::apache::arrow::computeir::flatbuf::Relation *rel() const { + return GetPointer(VT_REL); + } + /// Expressions which will be evaluated to produce to + /// the rows of the aggregate relation's output. + const flatbuffers::Vector> *measures() const { + return GetPointer> *>(VT_MEASURES); + } + /// Keys by which `aggregations` will be grouped. + /// + /// The nested list here is to support grouping sets + /// eg + /// + /// SELECT a, b, c, sum(d) + /// FROM t + /// GROUP BY + /// GROUPING SETS ( + /// (a, b, c), + /// (a, b), + /// (a), + /// () + /// ); + const flatbuffers::Vector> *groupings() const { + return GetPointer> *>(VT_GROUPINGS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_REL) && + verifier.VerifyTable(rel()) && + VerifyOffsetRequired(verifier, VT_MEASURES) && + verifier.VerifyVector(measures()) && + verifier.VerifyVectorOfTables(measures()) && + VerifyOffsetRequired(verifier, VT_GROUPINGS) && + verifier.VerifyVector(groupings()) && + verifier.VerifyVectorOfTables(groupings()) && + verifier.EndTable(); + } +}; + +struct AggregateBuilder { + typedef Aggregate Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Aggregate::VT_BASE, base); + } + void add_rel(flatbuffers::Offset rel) { + fbb_.AddOffset(Aggregate::VT_REL, rel); + } + void add_measures(flatbuffers::Offset>> measures) { + fbb_.AddOffset(Aggregate::VT_MEASURES, measures); + } + void add_groupings(flatbuffers::Offset>> groupings) { + fbb_.AddOffset(Aggregate::VT_GROUPINGS, groupings); + } + explicit AggregateBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AggregateBuilder &operator=(const AggregateBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Aggregate::VT_BASE); + fbb_.Required(o, Aggregate::VT_REL); + fbb_.Required(o, Aggregate::VT_MEASURES); + fbb_.Required(o, Aggregate::VT_GROUPINGS); + return o; + } +}; + +inline flatbuffers::Offset CreateAggregate( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + flatbuffers::Offset>> measures = 0, + flatbuffers::Offset>> groupings = 0) { + AggregateBuilder builder_(_fbb); + builder_.add_groupings(groupings); + builder_.add_measures(measures); + builder_.add_rel(rel); + builder_.add_base(base); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateAggregateDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + const std::vector> *measures = nullptr, + const std::vector> *groupings = nullptr) { + auto measures__ = measures ? _fbb.CreateVector>(*measures) : 0; + auto groupings__ = groupings ? _fbb.CreateVector>(*groupings) : 0; + return org::apache::arrow::computeir::flatbuf::CreateAggregate( + _fbb, + base, + rel, + measures__, + groupings__); +} + +/// Join between two tables +struct Join FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef JoinBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_LEFT = 6, + VT_RIGHT = 8, + VT_ON_EXPRESSION = 10, + VT_JOIN_KIND = 12 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Left relation + const org::apache::arrow::computeir::flatbuf::Relation *left() const { + return GetPointer(VT_LEFT); + } + /// Right relation + const org::apache::arrow::computeir::flatbuf::Relation *right() const { + return GetPointer(VT_RIGHT); + } + /// The expression which will be evaluated against rows from each + /// input to determine whether they should be included in the + /// join relation's output. + const org::apache::arrow::computeir::flatbuf::Expression *on_expression() const { + return GetPointer(VT_ON_EXPRESSION); + } + /// The kind of join to use. + org::apache::arrow::computeir::flatbuf::JoinKind join_kind() const { + return static_cast(GetField(VT_JOIN_KIND, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_LEFT) && + verifier.VerifyTable(left()) && + VerifyOffsetRequired(verifier, VT_RIGHT) && + verifier.VerifyTable(right()) && + VerifyOffsetRequired(verifier, VT_ON_EXPRESSION) && + verifier.VerifyTable(on_expression()) && + VerifyField(verifier, VT_JOIN_KIND) && + verifier.EndTable(); + } +}; + +struct JoinBuilder { + typedef Join Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Join::VT_BASE, base); + } + void add_left(flatbuffers::Offset left) { + fbb_.AddOffset(Join::VT_LEFT, left); + } + void add_right(flatbuffers::Offset right) { + fbb_.AddOffset(Join::VT_RIGHT, right); + } + void add_on_expression(flatbuffers::Offset on_expression) { + fbb_.AddOffset(Join::VT_ON_EXPRESSION, on_expression); + } + void add_join_kind(org::apache::arrow::computeir::flatbuf::JoinKind join_kind) { + fbb_.AddElement(Join::VT_JOIN_KIND, static_cast(join_kind), 0); + } + explicit JoinBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + JoinBuilder &operator=(const JoinBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Join::VT_BASE); + fbb_.Required(o, Join::VT_LEFT); + fbb_.Required(o, Join::VT_RIGHT); + fbb_.Required(o, Join::VT_ON_EXPRESSION); + return o; + } +}; + +inline flatbuffers::Offset CreateJoin( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset left = 0, + flatbuffers::Offset right = 0, + flatbuffers::Offset on_expression = 0, + org::apache::arrow::computeir::flatbuf::JoinKind join_kind = org::apache::arrow::computeir::flatbuf::JoinKind::Anti) { + JoinBuilder builder_(_fbb); + builder_.add_on_expression(on_expression); + builder_.add_right(right); + builder_.add_left(left); + builder_.add_base(base); + builder_.add_join_kind(join_kind); + return builder_.Finish(); +} + +/// Order by relation +struct OrderBy FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OrderByBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REL = 6, + VT_KEYS = 8 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relation + const org::apache::arrow::computeir::flatbuf::Relation *rel() const { + return GetPointer(VT_REL); + } + /// Define sort order for rows of output. + /// Keys with higher precedence are ordered ahead of other keys. + const flatbuffers::Vector> *keys() const { + return GetPointer> *>(VT_KEYS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_REL) && + verifier.VerifyTable(rel()) && + VerifyOffsetRequired(verifier, VT_KEYS) && + verifier.VerifyVector(keys()) && + verifier.VerifyVectorOfTables(keys()) && + verifier.EndTable(); + } +}; + +struct OrderByBuilder { + typedef OrderBy Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(OrderBy::VT_BASE, base); + } + void add_rel(flatbuffers::Offset rel) { + fbb_.AddOffset(OrderBy::VT_REL, rel); + } + void add_keys(flatbuffers::Offset>> keys) { + fbb_.AddOffset(OrderBy::VT_KEYS, keys); + } + explicit OrderByBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OrderByBuilder &operator=(const OrderByBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, OrderBy::VT_BASE); + fbb_.Required(o, OrderBy::VT_REL); + fbb_.Required(o, OrderBy::VT_KEYS); + return o; + } +}; + +inline flatbuffers::Offset CreateOrderBy( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + flatbuffers::Offset>> keys = 0) { + OrderByBuilder builder_(_fbb); + builder_.add_keys(keys); + builder_.add_rel(rel); + builder_.add_base(base); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateOrderByDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + const std::vector> *keys = nullptr) { + auto keys__ = keys ? _fbb.CreateVector>(*keys) : 0; + return org::apache::arrow::computeir::flatbuf::CreateOrderBy( + _fbb, + base, + rel, + keys__); +} + +/// Limit operation +struct Limit FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LimitBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REL = 6, + VT_OFFSET = 8, + VT_COUNT = 10 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relation + const org::apache::arrow::computeir::flatbuf::Relation *rel() const { + return GetPointer(VT_REL); + } + /// Starting index of rows + uint32_t offset() const { + return GetField(VT_OFFSET, 0); + } + /// The maximum number of rows of output. + uint32_t count() const { + return GetField(VT_COUNT, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_REL) && + verifier.VerifyTable(rel()) && + VerifyField(verifier, VT_OFFSET) && + VerifyField(verifier, VT_COUNT) && + verifier.EndTable(); + } +}; + +struct LimitBuilder { + typedef Limit Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Limit::VT_BASE, base); + } + void add_rel(flatbuffers::Offset rel) { + fbb_.AddOffset(Limit::VT_REL, rel); + } + void add_offset(uint32_t offset) { + fbb_.AddElement(Limit::VT_OFFSET, offset, 0); + } + void add_count(uint32_t count) { + fbb_.AddElement(Limit::VT_COUNT, count, 0); + } + explicit LimitBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LimitBuilder &operator=(const LimitBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Limit::VT_BASE); + fbb_.Required(o, Limit::VT_REL); + return o; + } +}; + +inline flatbuffers::Offset CreateLimit( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset rel = 0, + uint32_t offset = 0, + uint32_t count = 0) { + LimitBuilder builder_(_fbb); + builder_.add_count(count); + builder_.add_offset(offset); + builder_.add_rel(rel); + builder_.add_base(base); + return builder_.Finish(); +} + +/// A set operation on two or more relations +struct SetOperation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SetOperationBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_RELS = 6, + VT_SET_OP = 8 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// Child relations + const flatbuffers::Vector> *rels() const { + return GetPointer> *>(VT_RELS); + } + /// The kind of set operation + org::apache::arrow::computeir::flatbuf::SetOpKind set_op() const { + return static_cast(GetField(VT_SET_OP, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_RELS) && + verifier.VerifyVector(rels()) && + verifier.VerifyVectorOfTables(rels()) && + VerifyField(verifier, VT_SET_OP) && + verifier.EndTable(); + } +}; + +struct SetOperationBuilder { + typedef SetOperation Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SetOperation::VT_BASE, base); + } + void add_rels(flatbuffers::Offset>> rels) { + fbb_.AddOffset(SetOperation::VT_RELS, rels); + } + void add_set_op(org::apache::arrow::computeir::flatbuf::SetOpKind set_op) { + fbb_.AddElement(SetOperation::VT_SET_OP, static_cast(set_op), 0); + } + explicit SetOperationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SetOperationBuilder &operator=(const SetOperationBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, SetOperation::VT_BASE); + fbb_.Required(o, SetOperation::VT_RELS); + return o; + } +}; + +inline flatbuffers::Offset CreateSetOperation( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset>> rels = 0, + org::apache::arrow::computeir::flatbuf::SetOpKind set_op = org::apache::arrow::computeir::flatbuf::SetOpKind::Union) { + SetOperationBuilder builder_(_fbb); + builder_.add_rels(rels); + builder_.add_base(base); + builder_.add_set_op(set_op); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSetOperationDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + const std::vector> *rels = nullptr, + org::apache::arrow::computeir::flatbuf::SetOpKind set_op = org::apache::arrow::computeir::flatbuf::SetOpKind::Union) { + auto rels__ = rels ? _fbb.CreateVector>(*rels) : 0; + return org::apache::arrow::computeir::flatbuf::CreateSetOperation( + _fbb, + base, + rels__, + set_op); +} + +/// A single column of literal values. +struct LiteralColumn FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LiteralColumnBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ELEMENTS = 4 + }; + /// The literal values of the column + const flatbuffers::Vector> *elements() const { + return GetPointer> *>(VT_ELEMENTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_ELEMENTS) && + verifier.VerifyVector(elements()) && + verifier.VerifyVectorOfTables(elements()) && + verifier.EndTable(); + } +}; + +struct LiteralColumnBuilder { + typedef LiteralColumn Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_elements(flatbuffers::Offset>> elements) { + fbb_.AddOffset(LiteralColumn::VT_ELEMENTS, elements); + } + explicit LiteralColumnBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LiteralColumnBuilder &operator=(const LiteralColumnBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, LiteralColumn::VT_ELEMENTS); + return o; + } +}; + +inline flatbuffers::Offset CreateLiteralColumn( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> elements = 0) { + LiteralColumnBuilder builder_(_fbb); + builder_.add_elements(elements); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateLiteralColumnDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *elements = nullptr) { + auto elements__ = elements ? _fbb.CreateVector>(*elements) : 0; + return org::apache::arrow::computeir::flatbuf::CreateLiteralColumn( + _fbb, + elements__); +} + +/// Literal relation +struct LiteralRelation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LiteralRelationBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_COLUMNS = 6 + }; + /// Common options + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + /// The columns of this literal relation. + const flatbuffers::Vector> *columns() const { + return GetPointer> *>(VT_COLUMNS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_COLUMNS) && + verifier.VerifyVector(columns()) && + verifier.VerifyVectorOfTables(columns()) && + verifier.EndTable(); + } +}; + +struct LiteralRelationBuilder { + typedef LiteralRelation Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(LiteralRelation::VT_BASE, base); + } + void add_columns(flatbuffers::Offset>> columns) { + fbb_.AddOffset(LiteralRelation::VT_COLUMNS, columns); + } + explicit LiteralRelationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LiteralRelationBuilder &operator=(const LiteralRelationBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, LiteralRelation::VT_BASE); + fbb_.Required(o, LiteralRelation::VT_COLUMNS); + return o; + } +}; + +inline flatbuffers::Offset CreateLiteralRelation( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset>> columns = 0) { + LiteralRelationBuilder builder_(_fbb); + builder_.add_columns(columns); + builder_.add_base(base); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateLiteralRelationDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + const std::vector> *columns = nullptr) { + auto columns__ = columns ? _fbb.CreateVector>(*columns) : 0; + return org::apache::arrow::computeir::flatbuf::CreateLiteralRelation( + _fbb, + base, + columns__); +} + +/// A table read +struct Table FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TableBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_NAME = 6, + VT_SCHEMA = 8 + }; + const org::apache::arrow::computeir::flatbuf::RelBase *base() const { + return GetPointer(VT_BASE); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const org::apache::arrow::flatbuf::Schema *schema() const { + return GetPointer(VT_SCHEMA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffsetRequired(verifier, VT_SCHEMA) && + verifier.VerifyTable(schema()) && + verifier.EndTable(); + } +}; + +struct TableBuilder { + typedef Table Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Table::VT_BASE, base); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Table::VT_NAME, name); + } + void add_schema(flatbuffers::Offset schema) { + fbb_.AddOffset(Table::VT_SCHEMA, schema); + } + explicit TableBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TableBuilder &operator=(const TableBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset
(end); + fbb_.Required(o, Table::VT_BASE); + fbb_.Required(o, Table::VT_NAME); + fbb_.Required(o, Table::VT_SCHEMA); + return o; + } +}; + +inline flatbuffers::Offset
CreateTable( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset name = 0, + flatbuffers::Offset schema = 0) { + TableBuilder builder_(_fbb); + builder_.add_schema(schema); + builder_.add_name(name); + builder_.add_base(base); + return builder_.Finish(); +} + +inline flatbuffers::Offset
CreateTableDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + const char *name = nullptr, + flatbuffers::Offset schema = 0) { + auto name__ = name ? _fbb.CreateString(name) : 0; + return org::apache::arrow::computeir::flatbuf::CreateTable( + _fbb, + base, + name__, + schema); +} + +/// A table holding an instance of the possible relation types. +struct Relation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RelationBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IMPL_TYPE = 4, + VT_IMPL = 6 + }; + org::apache::arrow::computeir::flatbuf::RelationImpl impl_type() const { + return static_cast(GetField(VT_IMPL_TYPE, 0)); + } + const void *impl() const { + return GetPointer(VT_IMPL); + } + template const T *impl_as() const; + const org::apache::arrow::computeir::flatbuf::Aggregate *impl_as_Aggregate() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Aggregate ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::SetOperation *impl_as_SetOperation() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::SetOperation ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Filter *impl_as_Filter() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Filter ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Limit *impl_as_Limit() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Limit ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::LiteralRelation *impl_as_LiteralRelation() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::LiteralRelation ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::OrderBy *impl_as_OrderBy() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::OrderBy ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Project *impl_as_Project() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Project ? static_cast(impl()) : nullptr; + } + const org::apache::arrow::computeir::flatbuf::Table *impl_as_Table() const { + return impl_type() == org::apache::arrow::computeir::flatbuf::RelationImpl::Table ? static_cast(impl()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IMPL_TYPE) && + VerifyOffsetRequired(verifier, VT_IMPL) && + VerifyRelationImpl(verifier, impl(), impl_type()) && + verifier.EndTable(); + } +}; + +template<> inline const org::apache::arrow::computeir::flatbuf::Aggregate *Relation::impl_as() const { + return impl_as_Aggregate(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::SetOperation *Relation::impl_as() const { + return impl_as_SetOperation(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Filter *Relation::impl_as() const { + return impl_as_Filter(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Limit *Relation::impl_as() const { + return impl_as_Limit(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::LiteralRelation *Relation::impl_as() const { + return impl_as_LiteralRelation(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::OrderBy *Relation::impl_as() const { + return impl_as_OrderBy(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Project *Relation::impl_as() const { + return impl_as_Project(); +} + +template<> inline const org::apache::arrow::computeir::flatbuf::Table *Relation::impl_as() const { + return impl_as_Table(); +} + +struct RelationBuilder { + typedef Relation Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_impl_type(org::apache::arrow::computeir::flatbuf::RelationImpl impl_type) { + fbb_.AddElement(Relation::VT_IMPL_TYPE, static_cast(impl_type), 0); + } + void add_impl(flatbuffers::Offset impl) { + fbb_.AddOffset(Relation::VT_IMPL, impl); + } + explicit RelationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RelationBuilder &operator=(const RelationBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Relation::VT_IMPL); + return o; + } +}; + +inline flatbuffers::Offset CreateRelation( + flatbuffers::FlatBufferBuilder &_fbb, + org::apache::arrow::computeir::flatbuf::RelationImpl impl_type = org::apache::arrow::computeir::flatbuf::RelationImpl::NONE, + flatbuffers::Offset impl = 0) { + RelationBuilder builder_(_fbb); + builder_.add_impl(impl); + builder_.add_impl_type(impl_type); + return builder_.Finish(); +} + +inline bool VerifyEmit(flatbuffers::Verifier &verifier, const void *obj, Emit type) { + switch (type) { + case Emit::NONE: { + return true; + } + case Emit::Remap: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Emit::PassThrough: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyEmitVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyEmit( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyRelationImpl(flatbuffers::Verifier &verifier, const void *obj, RelationImpl type) { + switch (type) { + case RelationImpl::NONE: { + return true; + } + case RelationImpl::Aggregate: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::SetOperation: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::Filter: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::Limit: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::LiteralRelation: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::OrderBy: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::Project: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RelationImpl::Table: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyRelationImplVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyRelationImpl( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const org::apache::arrow::computeir::flatbuf::Relation *GetRelation(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const org::apache::arrow::computeir::flatbuf::Relation *GetSizePrefixedRelation(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyRelationBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedRelationBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishRelationBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedRelationBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace flatbuf +} // namespace computeir +} // namespace arrow +} // namespace apache +} // namespace org + +#endif // FLATBUFFERS_GENERATED_RELATION_ORG_APACHE_ARROW_COMPUTEIR_FLATBUF_H_ diff --git a/cpp/src/generated/Schema_generated.h b/cpp/src/generated/Schema_generated.h index 1768b688e6aa6..79ffa661e4a6d 100644 --- a/cpp/src/generated/Schema_generated.h +++ b/cpp/src/generated/Schema_generated.h @@ -12,56 +12,81 @@ namespace arrow { namespace flatbuf { struct Null; +struct NullBuilder; struct Struct_; +struct Struct_Builder; struct List; +struct ListBuilder; struct LargeList; +struct LargeListBuilder; struct FixedSizeList; +struct FixedSizeListBuilder; struct Map; +struct MapBuilder; struct Union; +struct UnionBuilder; struct Int; +struct IntBuilder; struct FloatingPoint; +struct FloatingPointBuilder; struct Utf8; +struct Utf8Builder; struct Binary; +struct BinaryBuilder; struct LargeUtf8; +struct LargeUtf8Builder; struct LargeBinary; +struct LargeBinaryBuilder; struct FixedSizeBinary; +struct FixedSizeBinaryBuilder; struct Bool; +struct BoolBuilder; struct Decimal; +struct DecimalBuilder; struct Date; +struct DateBuilder; struct Time; +struct TimeBuilder; struct Timestamp; +struct TimestampBuilder; struct Interval; +struct IntervalBuilder; struct Duration; +struct DurationBuilder; struct KeyValue; +struct KeyValueBuilder; struct DictionaryEncoding; +struct DictionaryEncodingBuilder; struct Field; +struct FieldBuilder; struct Buffer; struct Schema; +struct SchemaBuilder; enum class MetadataVersion : int16_t { /// 0.1.0 (October 2016). @@ -612,6 +637,7 @@ FLATBUFFERS_STRUCT_END(Buffer, 16); /// These are stored in the flatbuffer in the Type union below struct Null FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NullBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -619,6 +645,7 @@ struct Null FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct NullBuilder { + typedef Null Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit NullBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -643,6 +670,7 @@ inline flatbuffers::Offset CreateNull( /// (according to the physical memory layout). We used Struct_ here as /// Struct is a reserved word in Flatbuffers struct Struct_ FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Struct_Builder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -650,6 +678,7 @@ struct Struct_ FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct Struct_Builder { + typedef Struct_ Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit Struct_Builder(flatbuffers::FlatBufferBuilder &_fbb) @@ -671,6 +700,7 @@ inline flatbuffers::Offset CreateStruct_( } struct List FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ListBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -678,6 +708,7 @@ struct List FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct ListBuilder { + typedef List Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit ListBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -701,6 +732,7 @@ inline flatbuffers::Offset CreateList( /// Same as List, but with 64-bit offsets, allowing to represent /// extremely large data values. struct LargeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LargeListBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -708,6 +740,7 @@ struct LargeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct LargeListBuilder { + typedef LargeList Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit LargeListBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -729,6 +762,7 @@ inline flatbuffers::Offset CreateLargeList( } struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FixedSizeListBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_LISTSIZE = 4 }; @@ -744,6 +778,7 @@ struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct FixedSizeListBuilder { + typedef FixedSizeList Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_listSize(int32_t listSize) { @@ -795,6 +830,7 @@ inline flatbuffers::Offset CreateFixedSizeList( /// for Map can make Map an alias for List. The "layout" attribute for the Map /// field must have the same contents as a List. struct Map FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MapBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_KEYSSORTED = 4 }; @@ -810,6 +846,7 @@ struct Map FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct MapBuilder { + typedef Map Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_keysSorted(bool keysSorted) { @@ -840,6 +877,7 @@ inline flatbuffers::Offset CreateMap( /// optionally typeIds provides an indirection between the child offset and the type id /// for each child `typeIds[offset]` is the id used in the type vector struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UnionBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_MODE = 4, VT_TYPEIDS = 6 @@ -860,6 +898,7 @@ struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct UnionBuilder { + typedef Union Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_mode(org::apache::arrow::flatbuf::UnionMode mode) { @@ -902,6 +941,7 @@ inline flatbuffers::Offset CreateUnionDirect( } struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IntBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BITWIDTH = 4, VT_IS_SIGNED = 6 @@ -921,6 +961,7 @@ struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct IntBuilder { + typedef Int Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_bitWidth(int32_t bitWidth) { @@ -952,6 +993,7 @@ inline flatbuffers::Offset CreateInt( } struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FloatingPointBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PRECISION = 4 }; @@ -966,6 +1008,7 @@ struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct FloatingPointBuilder { + typedef FloatingPoint Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_precision(org::apache::arrow::flatbuf::Precision precision) { @@ -993,6 +1036,7 @@ inline flatbuffers::Offset CreateFloatingPoint( /// Unicode with UTF-8 encoding struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Utf8Builder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -1000,6 +1044,7 @@ struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct Utf8Builder { + typedef Utf8 Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit Utf8Builder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1022,6 +1067,7 @@ inline flatbuffers::Offset CreateUtf8( /// Opaque binary data struct Binary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BinaryBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -1029,6 +1075,7 @@ struct Binary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct BinaryBuilder { + typedef Binary Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit BinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1052,6 +1099,7 @@ inline flatbuffers::Offset CreateBinary( /// Same as Utf8, but with 64-bit offsets, allowing to represent /// extremely large data values. struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LargeUtf8Builder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -1059,6 +1107,7 @@ struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct LargeUtf8Builder { + typedef LargeUtf8 Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit LargeUtf8Builder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1082,6 +1131,7 @@ inline flatbuffers::Offset CreateLargeUtf8( /// Same as Binary, but with 64-bit offsets, allowing to represent /// extremely large data values. struct LargeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LargeBinaryBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -1089,6 +1139,7 @@ struct LargeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct LargeBinaryBuilder { + typedef LargeBinary Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit LargeBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1110,6 +1161,7 @@ inline flatbuffers::Offset CreateLargeBinary( } struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FixedSizeBinaryBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BYTEWIDTH = 4 }; @@ -1125,6 +1177,7 @@ struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct FixedSizeBinaryBuilder { + typedef FixedSizeBinary Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_byteWidth(int32_t byteWidth) { @@ -1151,6 +1204,7 @@ inline flatbuffers::Offset CreateFixedSizeBinary( } struct Bool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BoolBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); @@ -1158,6 +1212,7 @@ struct Bool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct BoolBuilder { + typedef Bool Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; explicit BoolBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1183,6 +1238,7 @@ inline flatbuffers::Offset CreateBool( /// are used. The representation uses the endianness indicated /// in the Schema. struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DecimalBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PRECISION = 4, VT_SCALE = 6, @@ -1211,6 +1267,7 @@ struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct DecimalBuilder { + typedef Decimal Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_precision(int32_t precision) { @@ -1246,13 +1303,14 @@ inline flatbuffers::Offset CreateDecimal( return builder_.Finish(); } -/// Date is either a 32-bit or 64-bit type representing elapsed time since UNIX -/// epoch (1970-01-01), stored in either of two units: +/// Date is either a 32-bit or 64-bit signed integer type representing an +/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units: /// /// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no /// leap seconds), where the values are evenly divisible by 86400000 /// * Days (32 bits) since the UNIX epoch struct Date FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DateBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_UNIT = 4 }; @@ -1267,6 +1325,7 @@ struct Date FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct DateBuilder { + typedef Date Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_unit(org::apache::arrow::flatbuf::DateUnit unit) { @@ -1292,10 +1351,22 @@ inline flatbuffers::Offset CreateDate( return builder_.Finish(); } -/// Time type. The physical storage type depends on the unit -/// - SECOND and MILLISECOND: 32 bits -/// - MICROSECOND and NANOSECOND: 64 bits +/// Time is either a 32-bit or 64-bit signed integer type representing an +/// elapsed time since midnight, stored in either of four units: seconds, +/// milliseconds, microseconds or nanoseconds. +/// +/// The integer `bitWidth` depends on the `unit` and must be one of the following: +/// * SECOND and MILLISECOND: 32 bits +/// * MICROSECOND and NANOSECOND: 64 bits +/// +/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds +/// (exclusive), adjusted for the time unit (for example, up to 86400000 +/// exclusive for the MILLISECOND unit). +/// This definition doesn't allow for leap seconds. Time values from +/// measurements with leap seconds will need to be corrected when ingesting +/// into Arrow (for example by replacing the value 86400 with 86399). struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TimeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_UNIT = 4, VT_BITWIDTH = 6 @@ -1315,6 +1386,7 @@ struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct TimeBuilder { + typedef Time Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) { @@ -1345,38 +1417,113 @@ inline flatbuffers::Offset