/** * Autogenerated by Thrift Compiler (0.11.0) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated */ #ifndef parquet_TYPES_H #define parquet_TYPES_H #include #include "duckdb/common/vector.hpp" #include "thrift/Thrift.h" #include "thrift/TApplicationException.h" #include "thrift/TBase.h" #include "thrift/protocol/TProtocol.h" #include "thrift/transport/TTransport.h" #include "thrift/stdcxx.h" #include "windows_compatibility.h" namespace duckdb_parquet { namespace format { struct Type { enum type { BOOLEAN = 0, INT32 = 1, INT64 = 2, INT96 = 3, FLOAT = 4, DOUBLE = 5, BYTE_ARRAY = 6, FIXED_LEN_BYTE_ARRAY = 7 }; }; extern const std::map _Type_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const Type::type& val); struct ConvertedType { enum type { UTF8 = 0, MAP = 1, MAP_KEY_VALUE = 2, LIST = 3, ENUM = 4, DECIMAL = 5, DATE = 6, TIME_MILLIS = 7, TIME_MICROS = 8, TIMESTAMP_MILLIS = 9, TIMESTAMP_MICROS = 10, UINT_8 = 11, UINT_16 = 12, UINT_32 = 13, UINT_64 = 14, INT_8 = 15, INT_16 = 16, INT_32 = 17, INT_64 = 18, JSON = 19, BSON = 20, INTERVAL = 21 }; }; extern const std::map _ConvertedType_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const ConvertedType::type& val); struct FieldRepetitionType { enum type { REQUIRED = 0, OPTIONAL = 1, REPEATED = 2 }; }; extern const std::map _FieldRepetitionType_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const FieldRepetitionType::type& val); struct Encoding { enum type { PLAIN = 0, PLAIN_DICTIONARY = 2, RLE = 3, BIT_PACKED = 4, DELTA_BINARY_PACKED = 5, DELTA_LENGTH_BYTE_ARRAY = 6, DELTA_BYTE_ARRAY = 7, RLE_DICTIONARY = 8 }; }; extern const std::map _Encoding_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const Encoding::type& val); struct CompressionCodec { enum type { UNCOMPRESSED = 0, SNAPPY = 1, GZIP = 2, LZO = 3, BROTLI = 4, LZ4 = 5, ZSTD = 6 }; }; extern const std::map _CompressionCodec_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const CompressionCodec::type& val); struct PageType { enum type { DATA_PAGE = 0, INDEX_PAGE = 1, DICTIONARY_PAGE = 2, DATA_PAGE_V2 = 3 }; }; extern const std::map _PageType_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const PageType::type& val); struct BoundaryOrder { enum type { UNORDERED = 0, ASCENDING = 1, DESCENDING = 2 }; }; extern const std::map _BoundaryOrder_VALUES_TO_NAMES; std::ostream& operator<<(std::ostream& out, const BoundaryOrder::type& val); class Statistics; class StringType; class UUIDType; class MapType; class ListType; class EnumType; class DateType; class NullType; class DecimalType; class MilliSeconds; class MicroSeconds; class NanoSeconds; class TimeUnit; class TimestampType; class TimeType; class IntType; class JsonType; class BsonType; class LogicalType; class SchemaElement; class DataPageHeader; class IndexPageHeader; class DictionaryPageHeader; class DataPageHeaderV2; class PageHeader; class KeyValue; class SortingColumn; class PageEncodingStats; class ColumnMetaData; class EncryptionWithFooterKey; class EncryptionWithColumnKey; class ColumnCryptoMetaData; class ColumnChunk; class RowGroup; class TypeDefinedOrder; class ColumnOrder; class PageLocation; class OffsetIndex; class ColumnIndex; class AesGcmV1; class AesGcmCtrV1; class EncryptionAlgorithm; class FileMetaData; class FileCryptoMetaData; typedef struct _Statistics__isset { _Statistics__isset() : max(false), min(false), null_count(false), distinct_count(false), max_value(false), min_value(false) {} bool max :1; bool min :1; bool null_count :1; bool distinct_count :1; bool max_value :1; bool min_value :1; } _Statistics__isset; class Statistics : public virtual ::duckdb_apache::thrift::TBase { public: Statistics(const Statistics&); Statistics& operator=(const Statistics&); Statistics() : max(), min(), null_count(0), distinct_count(0), max_value(), min_value() { } virtual ~Statistics() throw(); std::string max; std::string min; int64_t null_count; int64_t distinct_count; std::string max_value; std::string min_value; _Statistics__isset __isset; void __set_max(const std::string& val); void __set_min(const std::string& val); void __set_null_count(const int64_t val); void __set_distinct_count(const int64_t val); void __set_max_value(const std::string& val); void __set_min_value(const std::string& val); bool operator == (const Statistics & rhs) const { if (__isset.max != rhs.__isset.max) return false; else if (__isset.max && !(max == rhs.max)) return false; if (__isset.min != rhs.__isset.min) return false; else if (__isset.min && !(min == rhs.min)) return false; if (__isset.null_count != rhs.__isset.null_count) return false; else if (__isset.null_count && !(null_count == rhs.null_count)) return false; if (__isset.distinct_count != rhs.__isset.distinct_count) return false; else if (__isset.distinct_count && !(distinct_count == rhs.distinct_count)) return false; if (__isset.max_value != rhs.__isset.max_value) return false; else if (__isset.max_value && !(max_value == rhs.max_value)) return false; if (__isset.min_value != rhs.__isset.min_value) return false; else if (__isset.min_value && !(min_value == rhs.min_value)) return false; return true; } bool operator != (const Statistics &rhs) const { return !(*this == rhs); } bool operator < (const Statistics & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(Statistics &a, Statistics &b); std::ostream& operator<<(std::ostream& out, const Statistics& obj); class StringType : public virtual ::duckdb_apache::thrift::TBase { public: StringType(const StringType&); StringType& operator=(const StringType&); StringType() { } virtual ~StringType() throw(); bool operator == (const StringType & /* rhs */) const { return true; } bool operator != (const StringType &rhs) const { return !(*this == rhs); } bool operator < (const StringType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(StringType &a, StringType &b); std::ostream& operator<<(std::ostream& out, const StringType& obj); class UUIDType : public virtual ::duckdb_apache::thrift::TBase { public: UUIDType(const UUIDType&); UUIDType& operator=(const UUIDType&); UUIDType() { } virtual ~UUIDType() throw(); bool operator == (const UUIDType & /* rhs */) const { return true; } bool operator != (const UUIDType &rhs) const { return !(*this == rhs); } bool operator < (const UUIDType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(UUIDType &a, UUIDType &b); std::ostream& operator<<(std::ostream& out, const UUIDType& obj); class MapType : public virtual ::duckdb_apache::thrift::TBase { public: MapType(const MapType&); MapType& operator=(const MapType&); MapType() { } virtual ~MapType() throw(); bool operator == (const MapType & /* rhs */) const { return true; } bool operator != (const MapType &rhs) const { return !(*this == rhs); } bool operator < (const MapType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(MapType &a, MapType &b); std::ostream& operator<<(std::ostream& out, const MapType& obj); class ListType : public virtual ::duckdb_apache::thrift::TBase { public: ListType(const ListType&); ListType& operator=(const ListType&); ListType() { } virtual ~ListType() throw(); bool operator == (const ListType & /* rhs */) const { return true; } bool operator != (const ListType &rhs) const { return !(*this == rhs); } bool operator < (const ListType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ListType &a, ListType &b); std::ostream& operator<<(std::ostream& out, const ListType& obj); class EnumType : public virtual ::duckdb_apache::thrift::TBase { public: EnumType(const EnumType&); EnumType& operator=(const EnumType&); EnumType() { } virtual ~EnumType() throw(); bool operator == (const EnumType & /* rhs */) const { return true; } bool operator != (const EnumType &rhs) const { return !(*this == rhs); } bool operator < (const EnumType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(EnumType &a, EnumType &b); std::ostream& operator<<(std::ostream& out, const EnumType& obj); class DateType : public virtual ::duckdb_apache::thrift::TBase { public: DateType(const DateType&); DateType& operator=(const DateType&); DateType() { } virtual ~DateType() throw(); bool operator == (const DateType & /* rhs */) const { return true; } bool operator != (const DateType &rhs) const { return !(*this == rhs); } bool operator < (const DateType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(DateType &a, DateType &b); std::ostream& operator<<(std::ostream& out, const DateType& obj); class NullType : public virtual ::duckdb_apache::thrift::TBase { public: NullType(const NullType&); NullType& operator=(const NullType&); NullType() { } virtual ~NullType() throw(); bool operator == (const NullType & /* rhs */) const { return true; } bool operator != (const NullType &rhs) const { return !(*this == rhs); } bool operator < (const NullType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(NullType &a, NullType &b); std::ostream& operator<<(std::ostream& out, const NullType& obj); class DecimalType : public virtual ::duckdb_apache::thrift::TBase { public: DecimalType(const DecimalType&); DecimalType& operator=(const DecimalType&); DecimalType() : scale(0), precision(0) { } virtual ~DecimalType() throw(); int32_t scale; int32_t precision; void __set_scale(const int32_t val); void __set_precision(const int32_t val); bool operator == (const DecimalType & rhs) const { if (!(scale == rhs.scale)) return false; if (!(precision == rhs.precision)) return false; return true; } bool operator != (const DecimalType &rhs) const { return !(*this == rhs); } bool operator < (const DecimalType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(DecimalType &a, DecimalType &b); std::ostream& operator<<(std::ostream& out, const DecimalType& obj); class MilliSeconds : public virtual ::duckdb_apache::thrift::TBase { public: MilliSeconds(const MilliSeconds&); MilliSeconds& operator=(const MilliSeconds&); MilliSeconds() { } virtual ~MilliSeconds() throw(); bool operator == (const MilliSeconds & /* rhs */) const { return true; } bool operator != (const MilliSeconds &rhs) const { return !(*this == rhs); } bool operator < (const MilliSeconds & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(MilliSeconds &a, MilliSeconds &b); std::ostream& operator<<(std::ostream& out, const MilliSeconds& obj); class MicroSeconds : public virtual ::duckdb_apache::thrift::TBase { public: MicroSeconds(const MicroSeconds&); MicroSeconds& operator=(const MicroSeconds&); MicroSeconds() { } virtual ~MicroSeconds() throw(); bool operator == (const MicroSeconds & /* rhs */) const { return true; } bool operator != (const MicroSeconds &rhs) const { return !(*this == rhs); } bool operator < (const MicroSeconds & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(MicroSeconds &a, MicroSeconds &b); std::ostream& operator<<(std::ostream& out, const MicroSeconds& obj); class NanoSeconds : public virtual ::duckdb_apache::thrift::TBase { public: NanoSeconds(const NanoSeconds&); NanoSeconds& operator=(const NanoSeconds&); NanoSeconds() { } virtual ~NanoSeconds() throw(); bool operator == (const NanoSeconds & /* rhs */) const { return true; } bool operator != (const NanoSeconds &rhs) const { return !(*this == rhs); } bool operator < (const NanoSeconds & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(NanoSeconds &a, NanoSeconds &b); std::ostream& operator<<(std::ostream& out, const NanoSeconds& obj); typedef struct _TimeUnit__isset { _TimeUnit__isset() : MILLIS(false), MICROS(false), NANOS(false) {} bool MILLIS :1; bool MICROS :1; bool NANOS :1; } _TimeUnit__isset; class TimeUnit : public virtual ::duckdb_apache::thrift::TBase { public: TimeUnit(const TimeUnit&); TimeUnit& operator=(const TimeUnit&); TimeUnit() { } virtual ~TimeUnit() throw(); MilliSeconds MILLIS; MicroSeconds MICROS; NanoSeconds NANOS; _TimeUnit__isset __isset; void __set_MILLIS(const MilliSeconds& val); void __set_MICROS(const MicroSeconds& val); void __set_NANOS(const NanoSeconds& val); bool operator == (const TimeUnit & rhs) const { if (__isset.MILLIS != rhs.__isset.MILLIS) return false; else if (__isset.MILLIS && !(MILLIS == rhs.MILLIS)) return false; if (__isset.MICROS != rhs.__isset.MICROS) return false; else if (__isset.MICROS && !(MICROS == rhs.MICROS)) return false; if (__isset.NANOS != rhs.__isset.NANOS) return false; else if (__isset.NANOS && !(NANOS == rhs.NANOS)) return false; return true; } bool operator != (const TimeUnit &rhs) const { return !(*this == rhs); } bool operator < (const TimeUnit & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(TimeUnit &a, TimeUnit &b); std::ostream& operator<<(std::ostream& out, const TimeUnit& obj); class TimestampType : public virtual ::duckdb_apache::thrift::TBase { public: TimestampType(const TimestampType&); TimestampType& operator=(const TimestampType&); TimestampType() : isAdjustedToUTC(0) { } virtual ~TimestampType() throw(); bool isAdjustedToUTC; TimeUnit unit; void __set_isAdjustedToUTC(const bool val); void __set_unit(const TimeUnit& val); bool operator == (const TimestampType & rhs) const { if (!(isAdjustedToUTC == rhs.isAdjustedToUTC)) return false; if (!(unit == rhs.unit)) return false; return true; } bool operator != (const TimestampType &rhs) const { return !(*this == rhs); } bool operator < (const TimestampType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(TimestampType &a, TimestampType &b); std::ostream& operator<<(std::ostream& out, const TimestampType& obj); class TimeType : public virtual ::duckdb_apache::thrift::TBase { public: TimeType(const TimeType&); TimeType& operator=(const TimeType&); TimeType() : isAdjustedToUTC(0) { } virtual ~TimeType() throw(); bool isAdjustedToUTC; TimeUnit unit; void __set_isAdjustedToUTC(const bool val); void __set_unit(const TimeUnit& val); bool operator == (const TimeType & rhs) const { if (!(isAdjustedToUTC == rhs.isAdjustedToUTC)) return false; if (!(unit == rhs.unit)) return false; return true; } bool operator != (const TimeType &rhs) const { return !(*this == rhs); } bool operator < (const TimeType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(TimeType &a, TimeType &b); std::ostream& operator<<(std::ostream& out, const TimeType& obj); class IntType : public virtual ::duckdb_apache::thrift::TBase { public: IntType(const IntType&); IntType& operator=(const IntType&); IntType() : bitWidth(0), isSigned(0) { } virtual ~IntType() throw(); int8_t bitWidth; bool isSigned; void __set_bitWidth(const int8_t val); void __set_isSigned(const bool val); bool operator == (const IntType & rhs) const { if (!(bitWidth == rhs.bitWidth)) return false; if (!(isSigned == rhs.isSigned)) return false; return true; } bool operator != (const IntType &rhs) const { return !(*this == rhs); } bool operator < (const IntType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(IntType &a, IntType &b); std::ostream& operator<<(std::ostream& out, const IntType& obj); class JsonType : public virtual ::duckdb_apache::thrift::TBase { public: JsonType(const JsonType&); JsonType& operator=(const JsonType&); JsonType() { } virtual ~JsonType() throw(); bool operator == (const JsonType & /* rhs */) const { return true; } bool operator != (const JsonType &rhs) const { return !(*this == rhs); } bool operator < (const JsonType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(JsonType &a, JsonType &b); std::ostream& operator<<(std::ostream& out, const JsonType& obj); class BsonType : public virtual ::duckdb_apache::thrift::TBase { public: BsonType(const BsonType&); BsonType& operator=(const BsonType&); BsonType() { } virtual ~BsonType() throw(); bool operator == (const BsonType & /* rhs */) const { return true; } bool operator != (const BsonType &rhs) const { return !(*this == rhs); } bool operator < (const BsonType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(BsonType &a, BsonType &b); std::ostream& operator<<(std::ostream& out, const BsonType& obj); typedef struct _LogicalType__isset { _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false), UUID(false) {} bool STRING :1; bool MAP :1; bool LIST :1; bool ENUM :1; bool DECIMAL :1; bool DATE :1; bool TIME :1; bool TIMESTAMP :1; bool INTEGER :1; bool UNKNOWN :1; bool JSON :1; bool BSON :1; bool UUID :1; } _LogicalType__isset; class LogicalType : public virtual ::duckdb_apache::thrift::TBase { public: LogicalType(const LogicalType&); LogicalType& operator=(const LogicalType&); LogicalType() { } virtual ~LogicalType() throw(); StringType STRING; MapType MAP; ListType LIST; EnumType ENUM; DecimalType DECIMAL; DateType DATE; TimeType TIME; TimestampType TIMESTAMP; IntType INTEGER; NullType UNKNOWN; JsonType JSON; BsonType BSON; UUIDType UUID; _LogicalType__isset __isset; void __set_STRING(const StringType& val); void __set_MAP(const MapType& val); void __set_LIST(const ListType& val); void __set_ENUM(const EnumType& val); void __set_DECIMAL(const DecimalType& val); void __set_DATE(const DateType& val); void __set_TIME(const TimeType& val); void __set_TIMESTAMP(const TimestampType& val); void __set_INTEGER(const IntType& val); void __set_UNKNOWN(const NullType& val); void __set_JSON(const JsonType& val); void __set_BSON(const BsonType& val); void __set_UUID(const UUIDType& val); bool operator == (const LogicalType & rhs) const { if (__isset.STRING != rhs.__isset.STRING) return false; else if (__isset.STRING && !(STRING == rhs.STRING)) return false; if (__isset.MAP != rhs.__isset.MAP) return false; else if (__isset.MAP && !(MAP == rhs.MAP)) return false; if (__isset.LIST != rhs.__isset.LIST) return false; else if (__isset.LIST && !(LIST == rhs.LIST)) return false; if (__isset.ENUM != rhs.__isset.ENUM) return false; else if (__isset.ENUM && !(ENUM == rhs.ENUM)) return false; if (__isset.DECIMAL != rhs.__isset.DECIMAL) return false; else if (__isset.DECIMAL && !(DECIMAL == rhs.DECIMAL)) return false; if (__isset.DATE != rhs.__isset.DATE) return false; else if (__isset.DATE && !(DATE == rhs.DATE)) return false; if (__isset.TIME != rhs.__isset.TIME) return false; else if (__isset.TIME && !(TIME == rhs.TIME)) return false; if (__isset.TIMESTAMP != rhs.__isset.TIMESTAMP) return false; else if (__isset.TIMESTAMP && !(TIMESTAMP == rhs.TIMESTAMP)) return false; if (__isset.INTEGER != rhs.__isset.INTEGER) return false; else if (__isset.INTEGER && !(INTEGER == rhs.INTEGER)) return false; if (__isset.UNKNOWN != rhs.__isset.UNKNOWN) return false; else if (__isset.UNKNOWN && !(UNKNOWN == rhs.UNKNOWN)) return false; if (__isset.JSON != rhs.__isset.JSON) return false; else if (__isset.JSON && !(JSON == rhs.JSON)) return false; if (__isset.BSON != rhs.__isset.BSON) return false; else if (__isset.BSON && !(BSON == rhs.BSON)) return false; if (__isset.UUID != rhs.__isset.UUID) return false; else if (__isset.UUID && !(UUID == rhs.UUID)) return false; return true; } bool operator != (const LogicalType &rhs) const { return !(*this == rhs); } bool operator < (const LogicalType & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(LogicalType &a, LogicalType &b); std::ostream& operator<<(std::ostream& out, const LogicalType& obj); typedef struct _SchemaElement__isset { _SchemaElement__isset() : type(false), type_length(false), repetition_type(false), num_children(false), converted_type(false), scale(false), precision(false), field_id(false), logicalType(false) {} bool type :1; bool type_length :1; bool repetition_type :1; bool num_children :1; bool converted_type :1; bool scale :1; bool precision :1; bool field_id :1; bool logicalType :1; } _SchemaElement__isset; class SchemaElement : public virtual ::duckdb_apache::thrift::TBase { public: SchemaElement(const SchemaElement&); SchemaElement& operator=(const SchemaElement&); SchemaElement() : type((Type::type)0), type_length(0), repetition_type((FieldRepetitionType::type)0), name(), num_children(0), converted_type((ConvertedType::type)0), scale(0), precision(0), field_id(0) { } virtual ~SchemaElement() throw(); Type::type type; int32_t type_length; FieldRepetitionType::type repetition_type; std::string name; int32_t num_children; ConvertedType::type converted_type; int32_t scale; int32_t precision; int32_t field_id; LogicalType logicalType; _SchemaElement__isset __isset; void __set_type(const Type::type val); void __set_type_length(const int32_t val); void __set_repetition_type(const FieldRepetitionType::type val); void __set_name(const std::string& val); void __set_num_children(const int32_t val); void __set_converted_type(const ConvertedType::type val); void __set_scale(const int32_t val); void __set_precision(const int32_t val); void __set_field_id(const int32_t val); void __set_logicalType(const LogicalType& val); bool operator == (const SchemaElement & rhs) const { if (__isset.type != rhs.__isset.type) return false; else if (__isset.type && !(type == rhs.type)) return false; if (__isset.type_length != rhs.__isset.type_length) return false; else if (__isset.type_length && !(type_length == rhs.type_length)) return false; if (__isset.repetition_type != rhs.__isset.repetition_type) return false; else if (__isset.repetition_type && !(repetition_type == rhs.repetition_type)) return false; if (!(name == rhs.name)) return false; if (__isset.num_children != rhs.__isset.num_children) return false; else if (__isset.num_children && !(num_children == rhs.num_children)) return false; if (__isset.converted_type != rhs.__isset.converted_type) return false; else if (__isset.converted_type && !(converted_type == rhs.converted_type)) return false; if (__isset.scale != rhs.__isset.scale) return false; else if (__isset.scale && !(scale == rhs.scale)) return false; if (__isset.precision != rhs.__isset.precision) return false; else if (__isset.precision && !(precision == rhs.precision)) return false; if (__isset.field_id != rhs.__isset.field_id) return false; else if (__isset.field_id && !(field_id == rhs.field_id)) return false; if (__isset.logicalType != rhs.__isset.logicalType) return false; else if (__isset.logicalType && !(logicalType == rhs.logicalType)) return false; return true; } bool operator != (const SchemaElement &rhs) const { return !(*this == rhs); } bool operator < (const SchemaElement & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(SchemaElement &a, SchemaElement &b); std::ostream& operator<<(std::ostream& out, const SchemaElement& obj); typedef struct _DataPageHeader__isset { _DataPageHeader__isset() : statistics(false) {} bool statistics :1; } _DataPageHeader__isset; class DataPageHeader : public virtual ::duckdb_apache::thrift::TBase { public: DataPageHeader(const DataPageHeader&); DataPageHeader& operator=(const DataPageHeader&); DataPageHeader() : num_values(0), encoding((Encoding::type)0), definition_level_encoding((Encoding::type)0), repetition_level_encoding((Encoding::type)0) { } virtual ~DataPageHeader() throw(); int32_t num_values; Encoding::type encoding; Encoding::type definition_level_encoding; Encoding::type repetition_level_encoding; Statistics statistics; _DataPageHeader__isset __isset; void __set_num_values(const int32_t val); void __set_encoding(const Encoding::type val); void __set_definition_level_encoding(const Encoding::type val); void __set_repetition_level_encoding(const Encoding::type val); void __set_statistics(const Statistics& val); bool operator == (const DataPageHeader & rhs) const { if (!(num_values == rhs.num_values)) return false; if (!(encoding == rhs.encoding)) return false; if (!(definition_level_encoding == rhs.definition_level_encoding)) return false; if (!(repetition_level_encoding == rhs.repetition_level_encoding)) return false; if (__isset.statistics != rhs.__isset.statistics) return false; else if (__isset.statistics && !(statistics == rhs.statistics)) return false; return true; } bool operator != (const DataPageHeader &rhs) const { return !(*this == rhs); } bool operator < (const DataPageHeader & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(DataPageHeader &a, DataPageHeader &b); std::ostream& operator<<(std::ostream& out, const DataPageHeader& obj); class IndexPageHeader : public virtual ::duckdb_apache::thrift::TBase { public: IndexPageHeader(const IndexPageHeader&); IndexPageHeader& operator=(const IndexPageHeader&); IndexPageHeader() { } virtual ~IndexPageHeader() throw(); bool operator == (const IndexPageHeader & /* rhs */) const { return true; } bool operator != (const IndexPageHeader &rhs) const { return !(*this == rhs); } bool operator < (const IndexPageHeader & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(IndexPageHeader &a, IndexPageHeader &b); std::ostream& operator<<(std::ostream& out, const IndexPageHeader& obj); typedef struct _DictionaryPageHeader__isset { _DictionaryPageHeader__isset() : is_sorted(false) {} bool is_sorted :1; } _DictionaryPageHeader__isset; class DictionaryPageHeader : public virtual ::duckdb_apache::thrift::TBase { public: DictionaryPageHeader(const DictionaryPageHeader&); DictionaryPageHeader& operator=(const DictionaryPageHeader&); DictionaryPageHeader() : num_values(0), encoding((Encoding::type)0), is_sorted(0) { } virtual ~DictionaryPageHeader() throw(); int32_t num_values; Encoding::type encoding; bool is_sorted; _DictionaryPageHeader__isset __isset; void __set_num_values(const int32_t val); void __set_encoding(const Encoding::type val); void __set_is_sorted(const bool val); bool operator == (const DictionaryPageHeader & rhs) const { if (!(num_values == rhs.num_values)) return false; if (!(encoding == rhs.encoding)) return false; if (__isset.is_sorted != rhs.__isset.is_sorted) return false; else if (__isset.is_sorted && !(is_sorted == rhs.is_sorted)) return false; return true; } bool operator != (const DictionaryPageHeader &rhs) const { return !(*this == rhs); } bool operator < (const DictionaryPageHeader & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(DictionaryPageHeader &a, DictionaryPageHeader &b); std::ostream& operator<<(std::ostream& out, const DictionaryPageHeader& obj); typedef struct _DataPageHeaderV2__isset { _DataPageHeaderV2__isset() : is_compressed(true), statistics(false) {} bool is_compressed :1; bool statistics :1; } _DataPageHeaderV2__isset; class DataPageHeaderV2 : public virtual ::duckdb_apache::thrift::TBase { public: DataPageHeaderV2(const DataPageHeaderV2&); DataPageHeaderV2& operator=(const DataPageHeaderV2&); DataPageHeaderV2() : num_values(0), num_nulls(0), num_rows(0), encoding((Encoding::type)0), definition_levels_byte_length(0), repetition_levels_byte_length(0), is_compressed(true) { } virtual ~DataPageHeaderV2() throw(); int32_t num_values; int32_t num_nulls; int32_t num_rows; Encoding::type encoding; int32_t definition_levels_byte_length; int32_t repetition_levels_byte_length; bool is_compressed; Statistics statistics; _DataPageHeaderV2__isset __isset; void __set_num_values(const int32_t val); void __set_num_nulls(const int32_t val); void __set_num_rows(const int32_t val); void __set_encoding(const Encoding::type val); void __set_definition_levels_byte_length(const int32_t val); void __set_repetition_levels_byte_length(const int32_t val); void __set_is_compressed(const bool val); void __set_statistics(const Statistics& val); bool operator == (const DataPageHeaderV2 & rhs) const { if (!(num_values == rhs.num_values)) return false; if (!(num_nulls == rhs.num_nulls)) return false; if (!(num_rows == rhs.num_rows)) return false; if (!(encoding == rhs.encoding)) return false; if (!(definition_levels_byte_length == rhs.definition_levels_byte_length)) return false; if (!(repetition_levels_byte_length == rhs.repetition_levels_byte_length)) return false; if (__isset.is_compressed != rhs.__isset.is_compressed) return false; else if (__isset.is_compressed && !(is_compressed == rhs.is_compressed)) return false; if (__isset.statistics != rhs.__isset.statistics) return false; else if (__isset.statistics && !(statistics == rhs.statistics)) return false; return true; } bool operator != (const DataPageHeaderV2 &rhs) const { return !(*this == rhs); } bool operator < (const DataPageHeaderV2 & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b); std::ostream& operator<<(std::ostream& out, const DataPageHeaderV2& obj); typedef struct _PageHeader__isset { _PageHeader__isset() : crc(false), data_page_header(false), index_page_header(false), dictionary_page_header(false), data_page_header_v2(false) {} bool crc :1; bool data_page_header :1; bool index_page_header :1; bool dictionary_page_header :1; bool data_page_header_v2 :1; } _PageHeader__isset; class PageHeader : public virtual ::duckdb_apache::thrift::TBase { public: PageHeader(const PageHeader&); PageHeader& operator=(const PageHeader&); PageHeader() : type((PageType::type)0), uncompressed_page_size(0), compressed_page_size(0), crc(0) { } virtual ~PageHeader() throw(); PageType::type type; int32_t uncompressed_page_size; int32_t compressed_page_size; int32_t crc; DataPageHeader data_page_header; IndexPageHeader index_page_header; DictionaryPageHeader dictionary_page_header; DataPageHeaderV2 data_page_header_v2; _PageHeader__isset __isset; void __set_type(const PageType::type val); void __set_uncompressed_page_size(const int32_t val); void __set_compressed_page_size(const int32_t val); void __set_crc(const int32_t val); void __set_data_page_header(const DataPageHeader& val); void __set_index_page_header(const IndexPageHeader& val); void __set_dictionary_page_header(const DictionaryPageHeader& val); void __set_data_page_header_v2(const DataPageHeaderV2& val); bool operator == (const PageHeader & rhs) const { if (!(type == rhs.type)) return false; if (!(uncompressed_page_size == rhs.uncompressed_page_size)) return false; if (!(compressed_page_size == rhs.compressed_page_size)) return false; if (__isset.crc != rhs.__isset.crc) return false; else if (__isset.crc && !(crc == rhs.crc)) return false; if (__isset.data_page_header != rhs.__isset.data_page_header) return false; else if (__isset.data_page_header && !(data_page_header == rhs.data_page_header)) return false; if (__isset.index_page_header != rhs.__isset.index_page_header) return false; else if (__isset.index_page_header && !(index_page_header == rhs.index_page_header)) return false; if (__isset.dictionary_page_header != rhs.__isset.dictionary_page_header) return false; else if (__isset.dictionary_page_header && !(dictionary_page_header == rhs.dictionary_page_header)) return false; if (__isset.data_page_header_v2 != rhs.__isset.data_page_header_v2) return false; else if (__isset.data_page_header_v2 && !(data_page_header_v2 == rhs.data_page_header_v2)) return false; return true; } bool operator != (const PageHeader &rhs) const { return !(*this == rhs); } bool operator < (const PageHeader & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(PageHeader &a, PageHeader &b); std::ostream& operator<<(std::ostream& out, const PageHeader& obj); typedef struct _KeyValue__isset { _KeyValue__isset() : value(false) {} bool value :1; } _KeyValue__isset; class KeyValue : public virtual ::duckdb_apache::thrift::TBase { public: KeyValue(const KeyValue&); KeyValue& operator=(const KeyValue&); KeyValue() : key(), value() { } virtual ~KeyValue() throw(); std::string key; std::string value; _KeyValue__isset __isset; void __set_key(const std::string& val); void __set_value(const std::string& val); bool operator == (const KeyValue & rhs) const { if (!(key == rhs.key)) return false; if (__isset.value != rhs.__isset.value) return false; else if (__isset.value && !(value == rhs.value)) return false; return true; } bool operator != (const KeyValue &rhs) const { return !(*this == rhs); } bool operator < (const KeyValue & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(KeyValue &a, KeyValue &b); std::ostream& operator<<(std::ostream& out, const KeyValue& obj); class SortingColumn : public virtual ::duckdb_apache::thrift::TBase { public: SortingColumn(const SortingColumn&); SortingColumn& operator=(const SortingColumn&); SortingColumn() : column_idx(0), descending(0), nulls_first(0) { } virtual ~SortingColumn() throw(); int32_t column_idx; bool descending; bool nulls_first; void __set_column_idx(const int32_t val); void __set_descending(const bool val); void __set_nulls_first(const bool val); bool operator == (const SortingColumn & rhs) const { if (!(column_idx == rhs.column_idx)) return false; if (!(descending == rhs.descending)) return false; if (!(nulls_first == rhs.nulls_first)) return false; return true; } bool operator != (const SortingColumn &rhs) const { return !(*this == rhs); } bool operator < (const SortingColumn & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(SortingColumn &a, SortingColumn &b); std::ostream& operator<<(std::ostream& out, const SortingColumn& obj); class PageEncodingStats : public virtual ::duckdb_apache::thrift::TBase { public: PageEncodingStats(const PageEncodingStats&); PageEncodingStats& operator=(const PageEncodingStats&); PageEncodingStats() : page_type((PageType::type)0), encoding((Encoding::type)0), count(0) { } virtual ~PageEncodingStats() throw(); PageType::type page_type; Encoding::type encoding; int32_t count; void __set_page_type(const PageType::type val); void __set_encoding(const Encoding::type val); void __set_count(const int32_t val); bool operator == (const PageEncodingStats & rhs) const { if (!(page_type == rhs.page_type)) return false; if (!(encoding == rhs.encoding)) return false; if (!(count == rhs.count)) return false; return true; } bool operator != (const PageEncodingStats &rhs) const { return !(*this == rhs); } bool operator < (const PageEncodingStats & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(PageEncodingStats &a, PageEncodingStats &b); std::ostream& operator<<(std::ostream& out, const PageEncodingStats& obj); typedef struct _ColumnMetaData__isset { _ColumnMetaData__isset() : key_value_metadata(false), index_page_offset(false), dictionary_page_offset(false), statistics(false), encoding_stats(false) {} bool key_value_metadata :1; bool index_page_offset :1; bool dictionary_page_offset :1; bool statistics :1; bool encoding_stats :1; } _ColumnMetaData__isset; class ColumnMetaData : public virtual ::duckdb_apache::thrift::TBase { public: ColumnMetaData(const ColumnMetaData&); ColumnMetaData& operator=(const ColumnMetaData&); ColumnMetaData() : type((Type::type)0), codec((CompressionCodec::type)0), num_values(0), total_uncompressed_size(0), total_compressed_size(0), data_page_offset(0), index_page_offset(0), dictionary_page_offset(0) { } virtual ~ColumnMetaData() throw(); Type::type type; duckdb::vector encodings; duckdb::vector path_in_schema; CompressionCodec::type codec; int64_t num_values; int64_t total_uncompressed_size; int64_t total_compressed_size; duckdb::vector key_value_metadata; int64_t data_page_offset; int64_t index_page_offset; int64_t dictionary_page_offset; Statistics statistics; duckdb::vector encoding_stats; _ColumnMetaData__isset __isset; void __set_type(const Type::type val); void __set_encodings(const duckdb::vector & val); void __set_path_in_schema(const duckdb::vector & val); void __set_codec(const CompressionCodec::type val); void __set_num_values(const int64_t val); void __set_total_uncompressed_size(const int64_t val); void __set_total_compressed_size(const int64_t val); void __set_key_value_metadata(const duckdb::vector & val); void __set_data_page_offset(const int64_t val); void __set_index_page_offset(const int64_t val); void __set_dictionary_page_offset(const int64_t val); void __set_statistics(const Statistics& val); void __set_encoding_stats(const duckdb::vector & val); bool operator == (const ColumnMetaData & rhs) const { if (!(type == rhs.type)) return false; if (!(encodings == rhs.encodings)) return false; if (!(path_in_schema == rhs.path_in_schema)) return false; if (!(codec == rhs.codec)) return false; if (!(num_values == rhs.num_values)) return false; if (!(total_uncompressed_size == rhs.total_uncompressed_size)) return false; if (!(total_compressed_size == rhs.total_compressed_size)) return false; if (__isset.key_value_metadata != rhs.__isset.key_value_metadata) return false; else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata)) return false; if (!(data_page_offset == rhs.data_page_offset)) return false; if (__isset.index_page_offset != rhs.__isset.index_page_offset) return false; else if (__isset.index_page_offset && !(index_page_offset == rhs.index_page_offset)) return false; if (__isset.dictionary_page_offset != rhs.__isset.dictionary_page_offset) return false; else if (__isset.dictionary_page_offset && !(dictionary_page_offset == rhs.dictionary_page_offset)) return false; if (__isset.statistics != rhs.__isset.statistics) return false; else if (__isset.statistics && !(statistics == rhs.statistics)) return false; if (__isset.encoding_stats != rhs.__isset.encoding_stats) return false; else if (__isset.encoding_stats && !(encoding_stats == rhs.encoding_stats)) return false; return true; } bool operator != (const ColumnMetaData &rhs) const { return !(*this == rhs); } bool operator < (const ColumnMetaData & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ColumnMetaData &a, ColumnMetaData &b); std::ostream& operator<<(std::ostream& out, const ColumnMetaData& obj); class EncryptionWithFooterKey : public virtual ::duckdb_apache::thrift::TBase { public: EncryptionWithFooterKey(const EncryptionWithFooterKey&); EncryptionWithFooterKey& operator=(const EncryptionWithFooterKey&); EncryptionWithFooterKey() { } virtual ~EncryptionWithFooterKey() throw(); bool operator == (const EncryptionWithFooterKey & /* rhs */) const { return true; } bool operator != (const EncryptionWithFooterKey &rhs) const { return !(*this == rhs); } bool operator < (const EncryptionWithFooterKey & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b); std::ostream& operator<<(std::ostream& out, const EncryptionWithFooterKey& obj); typedef struct _EncryptionWithColumnKey__isset { _EncryptionWithColumnKey__isset() : key_metadata(false) {} bool key_metadata :1; } _EncryptionWithColumnKey__isset; class EncryptionWithColumnKey : public virtual ::duckdb_apache::thrift::TBase { public: EncryptionWithColumnKey(const EncryptionWithColumnKey&); EncryptionWithColumnKey& operator=(const EncryptionWithColumnKey&); EncryptionWithColumnKey() : key_metadata() { } virtual ~EncryptionWithColumnKey() throw(); duckdb::vector path_in_schema; std::string key_metadata; _EncryptionWithColumnKey__isset __isset; void __set_path_in_schema(const duckdb::vector & val); void __set_key_metadata(const std::string& val); bool operator == (const EncryptionWithColumnKey & rhs) const { if (!(path_in_schema == rhs.path_in_schema)) return false; if (__isset.key_metadata != rhs.__isset.key_metadata) return false; else if (__isset.key_metadata && !(key_metadata == rhs.key_metadata)) return false; return true; } bool operator != (const EncryptionWithColumnKey &rhs) const { return !(*this == rhs); } bool operator < (const EncryptionWithColumnKey & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b); std::ostream& operator<<(std::ostream& out, const EncryptionWithColumnKey& obj); typedef struct _ColumnCryptoMetaData__isset { _ColumnCryptoMetaData__isset() : ENCRYPTION_WITH_FOOTER_KEY(false), ENCRYPTION_WITH_COLUMN_KEY(false) {} bool ENCRYPTION_WITH_FOOTER_KEY :1; bool ENCRYPTION_WITH_COLUMN_KEY :1; } _ColumnCryptoMetaData__isset; class ColumnCryptoMetaData : public virtual ::duckdb_apache::thrift::TBase { public: ColumnCryptoMetaData(const ColumnCryptoMetaData&); ColumnCryptoMetaData& operator=(const ColumnCryptoMetaData&); ColumnCryptoMetaData() { } virtual ~ColumnCryptoMetaData() throw(); EncryptionWithFooterKey ENCRYPTION_WITH_FOOTER_KEY; EncryptionWithColumnKey ENCRYPTION_WITH_COLUMN_KEY; _ColumnCryptoMetaData__isset __isset; void __set_ENCRYPTION_WITH_FOOTER_KEY(const EncryptionWithFooterKey& val); void __set_ENCRYPTION_WITH_COLUMN_KEY(const EncryptionWithColumnKey& val); bool operator == (const ColumnCryptoMetaData & rhs) const { if (__isset.ENCRYPTION_WITH_FOOTER_KEY != rhs.__isset.ENCRYPTION_WITH_FOOTER_KEY) return false; else if (__isset.ENCRYPTION_WITH_FOOTER_KEY && !(ENCRYPTION_WITH_FOOTER_KEY == rhs.ENCRYPTION_WITH_FOOTER_KEY)) return false; if (__isset.ENCRYPTION_WITH_COLUMN_KEY != rhs.__isset.ENCRYPTION_WITH_COLUMN_KEY) return false; else if (__isset.ENCRYPTION_WITH_COLUMN_KEY && !(ENCRYPTION_WITH_COLUMN_KEY == rhs.ENCRYPTION_WITH_COLUMN_KEY)) return false; return true; } bool operator != (const ColumnCryptoMetaData &rhs) const { return !(*this == rhs); } bool operator < (const ColumnCryptoMetaData & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b); std::ostream& operator<<(std::ostream& out, const ColumnCryptoMetaData& obj); typedef struct _ColumnChunk__isset { _ColumnChunk__isset() : file_path(false), meta_data(false), offset_index_offset(false), offset_index_length(false), column_index_offset(false), column_index_length(false), crypto_metadata(false), encrypted_column_metadata(false) {} bool file_path :1; bool meta_data :1; bool offset_index_offset :1; bool offset_index_length :1; bool column_index_offset :1; bool column_index_length :1; bool crypto_metadata :1; bool encrypted_column_metadata :1; } _ColumnChunk__isset; class ColumnChunk : public virtual ::duckdb_apache::thrift::TBase { public: ColumnChunk(const ColumnChunk&); ColumnChunk& operator=(const ColumnChunk&); ColumnChunk() : file_path(), file_offset(0), offset_index_offset(0), offset_index_length(0), column_index_offset(0), column_index_length(0), encrypted_column_metadata() { } virtual ~ColumnChunk() throw(); std::string file_path; int64_t file_offset; ColumnMetaData meta_data; int64_t offset_index_offset; int32_t offset_index_length; int64_t column_index_offset; int32_t column_index_length; ColumnCryptoMetaData crypto_metadata; std::string encrypted_column_metadata; _ColumnChunk__isset __isset; void __set_file_path(const std::string& val); void __set_file_offset(const int64_t val); void __set_meta_data(const ColumnMetaData& val); void __set_offset_index_offset(const int64_t val); void __set_offset_index_length(const int32_t val); void __set_column_index_offset(const int64_t val); void __set_column_index_length(const int32_t val); void __set_crypto_metadata(const ColumnCryptoMetaData& val); void __set_encrypted_column_metadata(const std::string& val); bool operator == (const ColumnChunk & rhs) const { if (__isset.file_path != rhs.__isset.file_path) return false; else if (__isset.file_path && !(file_path == rhs.file_path)) return false; if (!(file_offset == rhs.file_offset)) return false; if (__isset.meta_data != rhs.__isset.meta_data) return false; else if (__isset.meta_data && !(meta_data == rhs.meta_data)) return false; if (__isset.offset_index_offset != rhs.__isset.offset_index_offset) return false; else if (__isset.offset_index_offset && !(offset_index_offset == rhs.offset_index_offset)) return false; if (__isset.offset_index_length != rhs.__isset.offset_index_length) return false; else if (__isset.offset_index_length && !(offset_index_length == rhs.offset_index_length)) return false; if (__isset.column_index_offset != rhs.__isset.column_index_offset) return false; else if (__isset.column_index_offset && !(column_index_offset == rhs.column_index_offset)) return false; if (__isset.column_index_length != rhs.__isset.column_index_length) return false; else if (__isset.column_index_length && !(column_index_length == rhs.column_index_length)) return false; if (__isset.crypto_metadata != rhs.__isset.crypto_metadata) return false; else if (__isset.crypto_metadata && !(crypto_metadata == rhs.crypto_metadata)) return false; if (__isset.encrypted_column_metadata != rhs.__isset.encrypted_column_metadata) return false; else if (__isset.encrypted_column_metadata && !(encrypted_column_metadata == rhs.encrypted_column_metadata)) return false; return true; } bool operator != (const ColumnChunk &rhs) const { return !(*this == rhs); } bool operator < (const ColumnChunk & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ColumnChunk &a, ColumnChunk &b); std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj); typedef struct _RowGroup__isset { _RowGroup__isset() : sorting_columns(false), file_offset(false), total_compressed_size(false), ordinal(false) {} bool sorting_columns :1; bool file_offset :1; bool total_compressed_size :1; bool ordinal :1; } _RowGroup__isset; class RowGroup : public virtual ::duckdb_apache::thrift::TBase { public: RowGroup(const RowGroup&); RowGroup& operator=(const RowGroup&); RowGroup() : total_byte_size(0), num_rows(0), file_offset(0), total_compressed_size(0), ordinal(0) { } virtual ~RowGroup() throw(); duckdb::vector columns; int64_t total_byte_size; int64_t num_rows; duckdb::vector sorting_columns; int64_t file_offset; int64_t total_compressed_size; int16_t ordinal; _RowGroup__isset __isset; void __set_columns(const duckdb::vector & val); void __set_total_byte_size(const int64_t val); void __set_num_rows(const int64_t val); void __set_sorting_columns(const duckdb::vector & val); void __set_file_offset(const int64_t val); void __set_total_compressed_size(const int64_t val); void __set_ordinal(const int16_t val); bool operator == (const RowGroup & rhs) const { if (!(columns == rhs.columns)) return false; if (!(total_byte_size == rhs.total_byte_size)) return false; if (!(num_rows == rhs.num_rows)) return false; if (__isset.sorting_columns != rhs.__isset.sorting_columns) return false; else if (__isset.sorting_columns && !(sorting_columns == rhs.sorting_columns)) return false; if (__isset.file_offset != rhs.__isset.file_offset) return false; else if (__isset.file_offset && !(file_offset == rhs.file_offset)) return false; if (__isset.total_compressed_size != rhs.__isset.total_compressed_size) return false; else if (__isset.total_compressed_size && !(total_compressed_size == rhs.total_compressed_size)) return false; if (__isset.ordinal != rhs.__isset.ordinal) return false; else if (__isset.ordinal && !(ordinal == rhs.ordinal)) return false; return true; } bool operator != (const RowGroup &rhs) const { return !(*this == rhs); } bool operator < (const RowGroup & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(RowGroup &a, RowGroup &b); std::ostream& operator<<(std::ostream& out, const RowGroup& obj); class TypeDefinedOrder : public virtual ::duckdb_apache::thrift::TBase { public: TypeDefinedOrder(const TypeDefinedOrder&); TypeDefinedOrder& operator=(const TypeDefinedOrder&); TypeDefinedOrder() { } virtual ~TypeDefinedOrder() throw(); bool operator == (const TypeDefinedOrder & /* rhs */) const { return true; } bool operator != (const TypeDefinedOrder &rhs) const { return !(*this == rhs); } bool operator < (const TypeDefinedOrder & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(TypeDefinedOrder &a, TypeDefinedOrder &b); std::ostream& operator<<(std::ostream& out, const TypeDefinedOrder& obj); typedef struct _ColumnOrder__isset { _ColumnOrder__isset() : TYPE_ORDER(false) {} bool TYPE_ORDER :1; } _ColumnOrder__isset; class ColumnOrder : public virtual ::duckdb_apache::thrift::TBase { public: ColumnOrder(const ColumnOrder&); ColumnOrder& operator=(const ColumnOrder&); ColumnOrder() { } virtual ~ColumnOrder() throw(); TypeDefinedOrder TYPE_ORDER; _ColumnOrder__isset __isset; void __set_TYPE_ORDER(const TypeDefinedOrder& val); bool operator == (const ColumnOrder & rhs) const { if (__isset.TYPE_ORDER != rhs.__isset.TYPE_ORDER) return false; else if (__isset.TYPE_ORDER && !(TYPE_ORDER == rhs.TYPE_ORDER)) return false; return true; } bool operator != (const ColumnOrder &rhs) const { return !(*this == rhs); } bool operator < (const ColumnOrder & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ColumnOrder &a, ColumnOrder &b); std::ostream& operator<<(std::ostream& out, const ColumnOrder& obj); class PageLocation : public virtual ::duckdb_apache::thrift::TBase { public: PageLocation(const PageLocation&); PageLocation& operator=(const PageLocation&); PageLocation() : offset(0), compressed_page_size(0), first_row_index(0) { } virtual ~PageLocation() throw(); int64_t offset; int32_t compressed_page_size; int64_t first_row_index; void __set_offset(const int64_t val); void __set_compressed_page_size(const int32_t val); void __set_first_row_index(const int64_t val); bool operator == (const PageLocation & rhs) const { if (!(offset == rhs.offset)) return false; if (!(compressed_page_size == rhs.compressed_page_size)) return false; if (!(first_row_index == rhs.first_row_index)) return false; return true; } bool operator != (const PageLocation &rhs) const { return !(*this == rhs); } bool operator < (const PageLocation & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(PageLocation &a, PageLocation &b); std::ostream& operator<<(std::ostream& out, const PageLocation& obj); class OffsetIndex : public virtual ::duckdb_apache::thrift::TBase { public: OffsetIndex(const OffsetIndex&); OffsetIndex& operator=(const OffsetIndex&); OffsetIndex() { } virtual ~OffsetIndex() throw(); duckdb::vector page_locations; void __set_page_locations(const duckdb::vector & val); bool operator == (const OffsetIndex & rhs) const { if (!(page_locations == rhs.page_locations)) return false; return true; } bool operator != (const OffsetIndex &rhs) const { return !(*this == rhs); } bool operator < (const OffsetIndex & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(OffsetIndex &a, OffsetIndex &b); std::ostream& operator<<(std::ostream& out, const OffsetIndex& obj); typedef struct _ColumnIndex__isset { _ColumnIndex__isset() : null_counts(false) {} bool null_counts :1; } _ColumnIndex__isset; class ColumnIndex : public virtual ::duckdb_apache::thrift::TBase { public: ColumnIndex(const ColumnIndex&); ColumnIndex& operator=(const ColumnIndex&); ColumnIndex() : boundary_order((BoundaryOrder::type)0) { } virtual ~ColumnIndex() throw(); duckdb::vector null_pages; duckdb::vector min_values; duckdb::vector max_values; BoundaryOrder::type boundary_order; duckdb::vector null_counts; _ColumnIndex__isset __isset; void __set_null_pages(const duckdb::vector & val); void __set_min_values(const duckdb::vector & val); void __set_max_values(const duckdb::vector & val); void __set_boundary_order(const BoundaryOrder::type val); void __set_null_counts(const duckdb::vector & val); bool operator == (const ColumnIndex & rhs) const { if (!(null_pages == rhs.null_pages)) return false; if (!(min_values == rhs.min_values)) return false; if (!(max_values == rhs.max_values)) return false; if (!(boundary_order == rhs.boundary_order)) return false; if (__isset.null_counts != rhs.__isset.null_counts) return false; else if (__isset.null_counts && !(null_counts == rhs.null_counts)) return false; return true; } bool operator != (const ColumnIndex &rhs) const { return !(*this == rhs); } bool operator < (const ColumnIndex & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(ColumnIndex &a, ColumnIndex &b); std::ostream& operator<<(std::ostream& out, const ColumnIndex& obj); typedef struct _AesGcmV1__isset { _AesGcmV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {} bool aad_prefix :1; bool aad_file_unique :1; bool supply_aad_prefix :1; } _AesGcmV1__isset; class AesGcmV1 : public virtual ::duckdb_apache::thrift::TBase { public: AesGcmV1(const AesGcmV1&); AesGcmV1& operator=(const AesGcmV1&); AesGcmV1() : aad_prefix(), aad_file_unique(), supply_aad_prefix(0) { } virtual ~AesGcmV1() throw(); std::string aad_prefix; std::string aad_file_unique; bool supply_aad_prefix; _AesGcmV1__isset __isset; void __set_aad_prefix(const std::string& val); void __set_aad_file_unique(const std::string& val); void __set_supply_aad_prefix(const bool val); bool operator == (const AesGcmV1 & rhs) const { if (__isset.aad_prefix != rhs.__isset.aad_prefix) return false; else if (__isset.aad_prefix && !(aad_prefix == rhs.aad_prefix)) return false; if (__isset.aad_file_unique != rhs.__isset.aad_file_unique) return false; else if (__isset.aad_file_unique && !(aad_file_unique == rhs.aad_file_unique)) return false; if (__isset.supply_aad_prefix != rhs.__isset.supply_aad_prefix) return false; else if (__isset.supply_aad_prefix && !(supply_aad_prefix == rhs.supply_aad_prefix)) return false; return true; } bool operator != (const AesGcmV1 &rhs) const { return !(*this == rhs); } bool operator < (const AesGcmV1 & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(AesGcmV1 &a, AesGcmV1 &b); std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj); typedef struct _AesGcmCtrV1__isset { _AesGcmCtrV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {} bool aad_prefix :1; bool aad_file_unique :1; bool supply_aad_prefix :1; } _AesGcmCtrV1__isset; class AesGcmCtrV1 : public virtual ::duckdb_apache::thrift::TBase { public: AesGcmCtrV1(const AesGcmCtrV1&); AesGcmCtrV1& operator=(const AesGcmCtrV1&); AesGcmCtrV1() : aad_prefix(), aad_file_unique(), supply_aad_prefix(0) { } virtual ~AesGcmCtrV1() throw(); std::string aad_prefix; std::string aad_file_unique; bool supply_aad_prefix; _AesGcmCtrV1__isset __isset; void __set_aad_prefix(const std::string& val); void __set_aad_file_unique(const std::string& val); void __set_supply_aad_prefix(const bool val); bool operator == (const AesGcmCtrV1 & rhs) const { if (__isset.aad_prefix != rhs.__isset.aad_prefix) return false; else if (__isset.aad_prefix && !(aad_prefix == rhs.aad_prefix)) return false; if (__isset.aad_file_unique != rhs.__isset.aad_file_unique) return false; else if (__isset.aad_file_unique && !(aad_file_unique == rhs.aad_file_unique)) return false; if (__isset.supply_aad_prefix != rhs.__isset.supply_aad_prefix) return false; else if (__isset.supply_aad_prefix && !(supply_aad_prefix == rhs.supply_aad_prefix)) return false; return true; } bool operator != (const AesGcmCtrV1 &rhs) const { return !(*this == rhs); } bool operator < (const AesGcmCtrV1 & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b); std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj); typedef struct _EncryptionAlgorithm__isset { _EncryptionAlgorithm__isset() : AES_GCM_V1(false), AES_GCM_CTR_V1(false) {} bool AES_GCM_V1 :1; bool AES_GCM_CTR_V1 :1; } _EncryptionAlgorithm__isset; class EncryptionAlgorithm : public virtual ::duckdb_apache::thrift::TBase { public: EncryptionAlgorithm(const EncryptionAlgorithm&); EncryptionAlgorithm& operator=(const EncryptionAlgorithm&); EncryptionAlgorithm() { } virtual ~EncryptionAlgorithm() throw(); AesGcmV1 AES_GCM_V1; AesGcmCtrV1 AES_GCM_CTR_V1; _EncryptionAlgorithm__isset __isset; void __set_AES_GCM_V1(const AesGcmV1& val); void __set_AES_GCM_CTR_V1(const AesGcmCtrV1& val); bool operator == (const EncryptionAlgorithm & rhs) const { if (__isset.AES_GCM_V1 != rhs.__isset.AES_GCM_V1) return false; else if (__isset.AES_GCM_V1 && !(AES_GCM_V1 == rhs.AES_GCM_V1)) return false; if (__isset.AES_GCM_CTR_V1 != rhs.__isset.AES_GCM_CTR_V1) return false; else if (__isset.AES_GCM_CTR_V1 && !(AES_GCM_CTR_V1 == rhs.AES_GCM_CTR_V1)) return false; return true; } bool operator != (const EncryptionAlgorithm &rhs) const { return !(*this == rhs); } bool operator < (const EncryptionAlgorithm & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b); std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj); typedef struct _FileMetaData__isset { _FileMetaData__isset() : key_value_metadata(false), created_by(false), column_orders(false), encryption_algorithm(false), footer_signing_key_metadata(false) {} bool key_value_metadata :1; bool created_by :1; bool column_orders :1; bool encryption_algorithm :1; bool footer_signing_key_metadata :1; } _FileMetaData__isset; class FileMetaData : public virtual ::duckdb_apache::thrift::TBase { public: FileMetaData(const FileMetaData&); FileMetaData& operator=(const FileMetaData&); FileMetaData() : version(0), num_rows(0), created_by(), footer_signing_key_metadata() { } virtual ~FileMetaData() throw(); int32_t version; duckdb::vector schema; int64_t num_rows; duckdb::vector row_groups; duckdb::vector key_value_metadata; std::string created_by; duckdb::vector column_orders; EncryptionAlgorithm encryption_algorithm; std::string footer_signing_key_metadata; _FileMetaData__isset __isset; void __set_version(const int32_t val); void __set_schema(const duckdb::vector & val); void __set_num_rows(const int64_t val); void __set_row_groups(const duckdb::vector & val); void __set_key_value_metadata(const duckdb::vector & val); void __set_created_by(const std::string& val); void __set_column_orders(const duckdb::vector & val); void __set_encryption_algorithm(const EncryptionAlgorithm& val); void __set_footer_signing_key_metadata(const std::string& val); bool operator == (const FileMetaData & rhs) const { if (!(version == rhs.version)) return false; if (!(schema == rhs.schema)) return false; if (!(num_rows == rhs.num_rows)) return false; if (!(row_groups == rhs.row_groups)) return false; if (__isset.key_value_metadata != rhs.__isset.key_value_metadata) return false; else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata)) return false; if (__isset.created_by != rhs.__isset.created_by) return false; else if (__isset.created_by && !(created_by == rhs.created_by)) return false; if (__isset.column_orders != rhs.__isset.column_orders) return false; else if (__isset.column_orders && !(column_orders == rhs.column_orders)) return false; if (__isset.encryption_algorithm != rhs.__isset.encryption_algorithm) return false; else if (__isset.encryption_algorithm && !(encryption_algorithm == rhs.encryption_algorithm)) return false; if (__isset.footer_signing_key_metadata != rhs.__isset.footer_signing_key_metadata) return false; else if (__isset.footer_signing_key_metadata && !(footer_signing_key_metadata == rhs.footer_signing_key_metadata)) return false; return true; } bool operator != (const FileMetaData &rhs) const { return !(*this == rhs); } bool operator < (const FileMetaData & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(FileMetaData &a, FileMetaData &b); std::ostream& operator<<(std::ostream& out, const FileMetaData& obj); typedef struct _FileCryptoMetaData__isset { _FileCryptoMetaData__isset() : key_metadata(false) {} bool key_metadata :1; } _FileCryptoMetaData__isset; class FileCryptoMetaData : public virtual ::duckdb_apache::thrift::TBase { public: FileCryptoMetaData(const FileCryptoMetaData&); FileCryptoMetaData& operator=(const FileCryptoMetaData&); FileCryptoMetaData() : key_metadata() { } virtual ~FileCryptoMetaData() throw(); EncryptionAlgorithm encryption_algorithm; std::string key_metadata; _FileCryptoMetaData__isset __isset; void __set_encryption_algorithm(const EncryptionAlgorithm& val); void __set_key_metadata(const std::string& val); bool operator == (const FileCryptoMetaData & rhs) const { if (!(encryption_algorithm == rhs.encryption_algorithm)) return false; if (__isset.key_metadata != rhs.__isset.key_metadata) return false; else if (__isset.key_metadata && !(key_metadata == rhs.key_metadata)) return false; return true; } bool operator != (const FileCryptoMetaData &rhs) const { return !(*this == rhs); } bool operator < (const FileCryptoMetaData & ) const; uint32_t read(::duckdb_apache::thrift::protocol::TProtocol* iprot); uint32_t write(::duckdb_apache::thrift::protocol::TProtocol* oprot) const; virtual void printTo(std::ostream& out) const; }; void swap(FileCryptoMetaData &a, FileCryptoMetaData &b); std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj); }} // namespace #endif