1/**
2 * Autogenerated by Thrift Compiler (0.11.0)
3 *
4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 * @generated
6 */
7#ifndef parquet_TYPES_H
8#define parquet_TYPES_H
9
10#include <iosfwd>
11
12#include <thrift/Thrift.h>
13#include <thrift/TApplicationException.h>
14#include <thrift/TBase.h>
15#include <thrift/protocol/TProtocol.h>
16#include <thrift/transport/TTransport.h>
17
18#include <thrift/stdcxx.h>
19
20#include "parquet/util/windows_compatibility.h"
21
22namespace parquet { namespace format {
23
24struct Type {
25 enum type {
26 BOOLEAN = 0,
27 INT32 = 1,
28 INT64 = 2,
29 INT96 = 3,
30 FLOAT = 4,
31 DOUBLE = 5,
32 BYTE_ARRAY = 6,
33 FIXED_LEN_BYTE_ARRAY = 7
34 };
35};
36
37extern const std::map<int, const char*> _Type_VALUES_TO_NAMES;
38
39std::ostream& operator<<(std::ostream& out, const Type::type& val);
40
41struct ConvertedType {
42 enum type {
43 UTF8 = 0,
44 MAP = 1,
45 MAP_KEY_VALUE = 2,
46 LIST = 3,
47 ENUM = 4,
48 DECIMAL = 5,
49 DATE = 6,
50 TIME_MILLIS = 7,
51 TIME_MICROS = 8,
52 TIMESTAMP_MILLIS = 9,
53 TIMESTAMP_MICROS = 10,
54 UINT_8 = 11,
55 UINT_16 = 12,
56 UINT_32 = 13,
57 UINT_64 = 14,
58 INT_8 = 15,
59 INT_16 = 16,
60 INT_32 = 17,
61 INT_64 = 18,
62 JSON = 19,
63 BSON = 20,
64 INTERVAL = 21
65 };
66};
67
68extern const std::map<int, const char*> _ConvertedType_VALUES_TO_NAMES;
69
70std::ostream& operator<<(std::ostream& out, const ConvertedType::type& val);
71
72struct FieldRepetitionType {
73 enum type {
74 REQUIRED = 0,
75 OPTIONAL = 1,
76 REPEATED = 2
77 };
78};
79
80extern const std::map<int, const char*> _FieldRepetitionType_VALUES_TO_NAMES;
81
82std::ostream& operator<<(std::ostream& out, const FieldRepetitionType::type& val);
83
84struct Encoding {
85 enum type {
86 PLAIN = 0,
87 PLAIN_DICTIONARY = 2,
88 RLE = 3,
89 BIT_PACKED = 4,
90 DELTA_BINARY_PACKED = 5,
91 DELTA_LENGTH_BYTE_ARRAY = 6,
92 DELTA_BYTE_ARRAY = 7,
93 RLE_DICTIONARY = 8
94 };
95};
96
97extern const std::map<int, const char*> _Encoding_VALUES_TO_NAMES;
98
99std::ostream& operator<<(std::ostream& out, const Encoding::type& val);
100
101struct CompressionCodec {
102 enum type {
103 UNCOMPRESSED = 0,
104 SNAPPY = 1,
105 GZIP = 2,
106 LZO = 3,
107 BROTLI = 4,
108 LZ4 = 5,
109 ZSTD = 6
110 };
111};
112
113extern const std::map<int, const char*> _CompressionCodec_VALUES_TO_NAMES;
114
115std::ostream& operator<<(std::ostream& out, const CompressionCodec::type& val);
116
117struct PageType {
118 enum type {
119 DATA_PAGE = 0,
120 INDEX_PAGE = 1,
121 DICTIONARY_PAGE = 2,
122 DATA_PAGE_V2 = 3
123 };
124};
125
126extern const std::map<int, const char*> _PageType_VALUES_TO_NAMES;
127
128std::ostream& operator<<(std::ostream& out, const PageType::type& val);
129
130struct BoundaryOrder {
131 enum type {
132 UNORDERED = 0,
133 ASCENDING = 1,
134 DESCENDING = 2
135 };
136};
137
138extern const std::map<int, const char*> _BoundaryOrder_VALUES_TO_NAMES;
139
140std::ostream& operator<<(std::ostream& out, const BoundaryOrder::type& val);
141
142class Statistics;
143
144class StringType;
145
146class UUIDType;
147
148class MapType;
149
150class ListType;
151
152class EnumType;
153
154class DateType;
155
156class NullType;
157
158class DecimalType;
159
160class MilliSeconds;
161
162class MicroSeconds;
163
164class TimeUnit;
165
166class TimestampType;
167
168class TimeType;
169
170class IntType;
171
172class JsonType;
173
174class BsonType;
175
176class LogicalType;
177
178class SchemaElement;
179
180class DataPageHeader;
181
182class IndexPageHeader;
183
184class DictionaryPageHeader;
185
186class DataPageHeaderV2;
187
188class PageHeader;
189
190class KeyValue;
191
192class SortingColumn;
193
194class PageEncodingStats;
195
196class ColumnMetaData;
197
198class EncryptionWithFooterKey;
199
200class EncryptionWithColumnKey;
201
202class ColumnCryptoMetaData;
203
204class ColumnChunk;
205
206class RowGroup;
207
208class TypeDefinedOrder;
209
210class ColumnOrder;
211
212class PageLocation;
213
214class OffsetIndex;
215
216class ColumnIndex;
217
218class FileMetaData;
219
220class AesGcmV1;
221
222class AesGcmCtrV1;
223
224class EncryptionAlgorithm;
225
226class FileCryptoMetaData;
227
228typedef struct _Statistics__isset {
229 _Statistics__isset() : max(false), min(false), null_count(false), distinct_count(false), max_value(false), min_value(false) {}
230 bool max :1;
231 bool min :1;
232 bool null_count :1;
233 bool distinct_count :1;
234 bool max_value :1;
235 bool min_value :1;
236} _Statistics__isset;
237
238class Statistics : public virtual ::apache::thrift::TBase {
239 public:
240
241 Statistics(const Statistics&);
242 Statistics& operator=(const Statistics&);
243 Statistics() : max(), min(), null_count(0), distinct_count(0), max_value(), min_value() {
244 }
245
246 virtual ~Statistics() throw();
247 std::string max;
248 std::string min;
249 int64_t null_count;
250 int64_t distinct_count;
251 std::string max_value;
252 std::string min_value;
253
254 _Statistics__isset __isset;
255
256 void __set_max(const std::string& val);
257
258 void __set_min(const std::string& val);
259
260 void __set_null_count(const int64_t val);
261
262 void __set_distinct_count(const int64_t val);
263
264 void __set_max_value(const std::string& val);
265
266 void __set_min_value(const std::string& val);
267
268 bool operator == (const Statistics & rhs) const
269 {
270 if (__isset.max != rhs.__isset.max)
271 return false;
272 else if (__isset.max && !(max == rhs.max))
273 return false;
274 if (__isset.min != rhs.__isset.min)
275 return false;
276 else if (__isset.min && !(min == rhs.min))
277 return false;
278 if (__isset.null_count != rhs.__isset.null_count)
279 return false;
280 else if (__isset.null_count && !(null_count == rhs.null_count))
281 return false;
282 if (__isset.distinct_count != rhs.__isset.distinct_count)
283 return false;
284 else if (__isset.distinct_count && !(distinct_count == rhs.distinct_count))
285 return false;
286 if (__isset.max_value != rhs.__isset.max_value)
287 return false;
288 else if (__isset.max_value && !(max_value == rhs.max_value))
289 return false;
290 if (__isset.min_value != rhs.__isset.min_value)
291 return false;
292 else if (__isset.min_value && !(min_value == rhs.min_value))
293 return false;
294 return true;
295 }
296 bool operator != (const Statistics &rhs) const {
297 return !(*this == rhs);
298 }
299
300 bool operator < (const Statistics & ) const;
301
302 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
303 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
304
305 virtual void printTo(std::ostream& out) const;
306};
307
308void swap(Statistics &a, Statistics &b);
309
310std::ostream& operator<<(std::ostream& out, const Statistics& obj);
311
312
313class StringType : public virtual ::apache::thrift::TBase {
314 public:
315
316 StringType(const StringType&);
317 StringType& operator=(const StringType&);
318 StringType() {
319 }
320
321 virtual ~StringType() throw();
322
323 bool operator == (const StringType & /* rhs */) const
324 {
325 return true;
326 }
327 bool operator != (const StringType &rhs) const {
328 return !(*this == rhs);
329 }
330
331 bool operator < (const StringType & ) const;
332
333 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
334 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
335
336 virtual void printTo(std::ostream& out) const;
337};
338
339void swap(StringType &a, StringType &b);
340
341std::ostream& operator<<(std::ostream& out, const StringType& obj);
342
343
344class UUIDType : public virtual ::apache::thrift::TBase {
345 public:
346
347 UUIDType(const UUIDType&);
348 UUIDType& operator=(const UUIDType&);
349 UUIDType() {
350 }
351
352 virtual ~UUIDType() throw();
353
354 bool operator == (const UUIDType & /* rhs */) const
355 {
356 return true;
357 }
358 bool operator != (const UUIDType &rhs) const {
359 return !(*this == rhs);
360 }
361
362 bool operator < (const UUIDType & ) const;
363
364 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
365 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
366
367 virtual void printTo(std::ostream& out) const;
368};
369
370void swap(UUIDType &a, UUIDType &b);
371
372std::ostream& operator<<(std::ostream& out, const UUIDType& obj);
373
374
375class MapType : public virtual ::apache::thrift::TBase {
376 public:
377
378 MapType(const MapType&);
379 MapType& operator=(const MapType&);
380 MapType() {
381 }
382
383 virtual ~MapType() throw();
384
385 bool operator == (const MapType & /* rhs */) const
386 {
387 return true;
388 }
389 bool operator != (const MapType &rhs) const {
390 return !(*this == rhs);
391 }
392
393 bool operator < (const MapType & ) const;
394
395 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
396 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
397
398 virtual void printTo(std::ostream& out) const;
399};
400
401void swap(MapType &a, MapType &b);
402
403std::ostream& operator<<(std::ostream& out, const MapType& obj);
404
405
406class ListType : public virtual ::apache::thrift::TBase {
407 public:
408
409 ListType(const ListType&);
410 ListType& operator=(const ListType&);
411 ListType() {
412 }
413
414 virtual ~ListType() throw();
415
416 bool operator == (const ListType & /* rhs */) const
417 {
418 return true;
419 }
420 bool operator != (const ListType &rhs) const {
421 return !(*this == rhs);
422 }
423
424 bool operator < (const ListType & ) const;
425
426 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
427 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
428
429 virtual void printTo(std::ostream& out) const;
430};
431
432void swap(ListType &a, ListType &b);
433
434std::ostream& operator<<(std::ostream& out, const ListType& obj);
435
436
437class EnumType : public virtual ::apache::thrift::TBase {
438 public:
439
440 EnumType(const EnumType&);
441 EnumType& operator=(const EnumType&);
442 EnumType() {
443 }
444
445 virtual ~EnumType() throw();
446
447 bool operator == (const EnumType & /* rhs */) const
448 {
449 return true;
450 }
451 bool operator != (const EnumType &rhs) const {
452 return !(*this == rhs);
453 }
454
455 bool operator < (const EnumType & ) const;
456
457 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
458 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
459
460 virtual void printTo(std::ostream& out) const;
461};
462
463void swap(EnumType &a, EnumType &b);
464
465std::ostream& operator<<(std::ostream& out, const EnumType& obj);
466
467
468class DateType : public virtual ::apache::thrift::TBase {
469 public:
470
471 DateType(const DateType&);
472 DateType& operator=(const DateType&);
473 DateType() {
474 }
475
476 virtual ~DateType() throw();
477
478 bool operator == (const DateType & /* rhs */) const
479 {
480 return true;
481 }
482 bool operator != (const DateType &rhs) const {
483 return !(*this == rhs);
484 }
485
486 bool operator < (const DateType & ) const;
487
488 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
489 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
490
491 virtual void printTo(std::ostream& out) const;
492};
493
494void swap(DateType &a, DateType &b);
495
496std::ostream& operator<<(std::ostream& out, const DateType& obj);
497
498
499class NullType : public virtual ::apache::thrift::TBase {
500 public:
501
502 NullType(const NullType&);
503 NullType& operator=(const NullType&);
504 NullType() {
505 }
506
507 virtual ~NullType() throw();
508
509 bool operator == (const NullType & /* rhs */) const
510 {
511 return true;
512 }
513 bool operator != (const NullType &rhs) const {
514 return !(*this == rhs);
515 }
516
517 bool operator < (const NullType & ) const;
518
519 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
520 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
521
522 virtual void printTo(std::ostream& out) const;
523};
524
525void swap(NullType &a, NullType &b);
526
527std::ostream& operator<<(std::ostream& out, const NullType& obj);
528
529
530class DecimalType : public virtual ::apache::thrift::TBase {
531 public:
532
533 DecimalType(const DecimalType&);
534 DecimalType& operator=(const DecimalType&);
535 DecimalType() : scale(0), precision(0) {
536 }
537
538 virtual ~DecimalType() throw();
539 int32_t scale;
540 int32_t precision;
541
542 void __set_scale(const int32_t val);
543
544 void __set_precision(const int32_t val);
545
546 bool operator == (const DecimalType & rhs) const
547 {
548 if (!(scale == rhs.scale))
549 return false;
550 if (!(precision == rhs.precision))
551 return false;
552 return true;
553 }
554 bool operator != (const DecimalType &rhs) const {
555 return !(*this == rhs);
556 }
557
558 bool operator < (const DecimalType & ) const;
559
560 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
561 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
562
563 virtual void printTo(std::ostream& out) const;
564};
565
566void swap(DecimalType &a, DecimalType &b);
567
568std::ostream& operator<<(std::ostream& out, const DecimalType& obj);
569
570
571class MilliSeconds : public virtual ::apache::thrift::TBase {
572 public:
573
574 MilliSeconds(const MilliSeconds&);
575 MilliSeconds& operator=(const MilliSeconds&);
576 MilliSeconds() {
577 }
578
579 virtual ~MilliSeconds() throw();
580
581 bool operator == (const MilliSeconds & /* rhs */) const
582 {
583 return true;
584 }
585 bool operator != (const MilliSeconds &rhs) const {
586 return !(*this == rhs);
587 }
588
589 bool operator < (const MilliSeconds & ) const;
590
591 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
592 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
593
594 virtual void printTo(std::ostream& out) const;
595};
596
597void swap(MilliSeconds &a, MilliSeconds &b);
598
599std::ostream& operator<<(std::ostream& out, const MilliSeconds& obj);
600
601
602class MicroSeconds : public virtual ::apache::thrift::TBase {
603 public:
604
605 MicroSeconds(const MicroSeconds&);
606 MicroSeconds& operator=(const MicroSeconds&);
607 MicroSeconds() {
608 }
609
610 virtual ~MicroSeconds() throw();
611
612 bool operator == (const MicroSeconds & /* rhs */) const
613 {
614 return true;
615 }
616 bool operator != (const MicroSeconds &rhs) const {
617 return !(*this == rhs);
618 }
619
620 bool operator < (const MicroSeconds & ) const;
621
622 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
623 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
624
625 virtual void printTo(std::ostream& out) const;
626};
627
628void swap(MicroSeconds &a, MicroSeconds &b);
629
630std::ostream& operator<<(std::ostream& out, const MicroSeconds& obj);
631
632typedef struct _TimeUnit__isset {
633 _TimeUnit__isset() : MILLIS(false), MICROS(false) {}
634 bool MILLIS :1;
635 bool MICROS :1;
636} _TimeUnit__isset;
637
638class TimeUnit : public virtual ::apache::thrift::TBase {
639 public:
640
641 TimeUnit(const TimeUnit&);
642 TimeUnit& operator=(const TimeUnit&);
643 TimeUnit() {
644 }
645
646 virtual ~TimeUnit() throw();
647 MilliSeconds MILLIS;
648 MicroSeconds MICROS;
649
650 _TimeUnit__isset __isset;
651
652 void __set_MILLIS(const MilliSeconds& val);
653
654 void __set_MICROS(const MicroSeconds& val);
655
656 bool operator == (const TimeUnit & rhs) const
657 {
658 if (__isset.MILLIS != rhs.__isset.MILLIS)
659 return false;
660 else if (__isset.MILLIS && !(MILLIS == rhs.MILLIS))
661 return false;
662 if (__isset.MICROS != rhs.__isset.MICROS)
663 return false;
664 else if (__isset.MICROS && !(MICROS == rhs.MICROS))
665 return false;
666 return true;
667 }
668 bool operator != (const TimeUnit &rhs) const {
669 return !(*this == rhs);
670 }
671
672 bool operator < (const TimeUnit & ) const;
673
674 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
675 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
676
677 virtual void printTo(std::ostream& out) const;
678};
679
680void swap(TimeUnit &a, TimeUnit &b);
681
682std::ostream& operator<<(std::ostream& out, const TimeUnit& obj);
683
684
685class TimestampType : public virtual ::apache::thrift::TBase {
686 public:
687
688 TimestampType(const TimestampType&);
689 TimestampType& operator=(const TimestampType&);
690 TimestampType() : isAdjustedToUTC(0) {
691 }
692
693 virtual ~TimestampType() throw();
694 bool isAdjustedToUTC;
695 TimeUnit unit;
696
697 void __set_isAdjustedToUTC(const bool val);
698
699 void __set_unit(const TimeUnit& val);
700
701 bool operator == (const TimestampType & rhs) const
702 {
703 if (!(isAdjustedToUTC == rhs.isAdjustedToUTC))
704 return false;
705 if (!(unit == rhs.unit))
706 return false;
707 return true;
708 }
709 bool operator != (const TimestampType &rhs) const {
710 return !(*this == rhs);
711 }
712
713 bool operator < (const TimestampType & ) const;
714
715 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
716 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
717
718 virtual void printTo(std::ostream& out) const;
719};
720
721void swap(TimestampType &a, TimestampType &b);
722
723std::ostream& operator<<(std::ostream& out, const TimestampType& obj);
724
725
726class TimeType : public virtual ::apache::thrift::TBase {
727 public:
728
729 TimeType(const TimeType&);
730 TimeType& operator=(const TimeType&);
731 TimeType() : isAdjustedToUTC(0) {
732 }
733
734 virtual ~TimeType() throw();
735 bool isAdjustedToUTC;
736 TimeUnit unit;
737
738 void __set_isAdjustedToUTC(const bool val);
739
740 void __set_unit(const TimeUnit& val);
741
742 bool operator == (const TimeType & rhs) const
743 {
744 if (!(isAdjustedToUTC == rhs.isAdjustedToUTC))
745 return false;
746 if (!(unit == rhs.unit))
747 return false;
748 return true;
749 }
750 bool operator != (const TimeType &rhs) const {
751 return !(*this == rhs);
752 }
753
754 bool operator < (const TimeType & ) const;
755
756 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
757 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
758
759 virtual void printTo(std::ostream& out) const;
760};
761
762void swap(TimeType &a, TimeType &b);
763
764std::ostream& operator<<(std::ostream& out, const TimeType& obj);
765
766
767class IntType : public virtual ::apache::thrift::TBase {
768 public:
769
770 IntType(const IntType&);
771 IntType& operator=(const IntType&);
772 IntType() : bitWidth(0), isSigned(0) {
773 }
774
775 virtual ~IntType() throw();
776 int8_t bitWidth;
777 bool isSigned;
778
779 void __set_bitWidth(const int8_t val);
780
781 void __set_isSigned(const bool val);
782
783 bool operator == (const IntType & rhs) const
784 {
785 if (!(bitWidth == rhs.bitWidth))
786 return false;
787 if (!(isSigned == rhs.isSigned))
788 return false;
789 return true;
790 }
791 bool operator != (const IntType &rhs) const {
792 return !(*this == rhs);
793 }
794
795 bool operator < (const IntType & ) const;
796
797 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
798 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
799
800 virtual void printTo(std::ostream& out) const;
801};
802
803void swap(IntType &a, IntType &b);
804
805std::ostream& operator<<(std::ostream& out, const IntType& obj);
806
807
808class JsonType : public virtual ::apache::thrift::TBase {
809 public:
810
811 JsonType(const JsonType&);
812 JsonType& operator=(const JsonType&);
813 JsonType() {
814 }
815
816 virtual ~JsonType() throw();
817
818 bool operator == (const JsonType & /* rhs */) const
819 {
820 return true;
821 }
822 bool operator != (const JsonType &rhs) const {
823 return !(*this == rhs);
824 }
825
826 bool operator < (const JsonType & ) const;
827
828 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
829 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
830
831 virtual void printTo(std::ostream& out) const;
832};
833
834void swap(JsonType &a, JsonType &b);
835
836std::ostream& operator<<(std::ostream& out, const JsonType& obj);
837
838
839class BsonType : public virtual ::apache::thrift::TBase {
840 public:
841
842 BsonType(const BsonType&);
843 BsonType& operator=(const BsonType&);
844 BsonType() {
845 }
846
847 virtual ~BsonType() throw();
848
849 bool operator == (const BsonType & /* rhs */) const
850 {
851 return true;
852 }
853 bool operator != (const BsonType &rhs) const {
854 return !(*this == rhs);
855 }
856
857 bool operator < (const BsonType & ) const;
858
859 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
860 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
861
862 virtual void printTo(std::ostream& out) const;
863};
864
865void swap(BsonType &a, BsonType &b);
866
867std::ostream& operator<<(std::ostream& out, const BsonType& obj);
868
869typedef struct _LogicalType__isset {
870 _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) {}
871 bool STRING :1;
872 bool MAP :1;
873 bool LIST :1;
874 bool ENUM :1;
875 bool DECIMAL :1;
876 bool DATE :1;
877 bool TIME :1;
878 bool TIMESTAMP :1;
879 bool INTEGER :1;
880 bool UNKNOWN :1;
881 bool JSON :1;
882 bool BSON :1;
883} _LogicalType__isset;
884
885class LogicalType : public virtual ::apache::thrift::TBase {
886 public:
887
888 LogicalType(const LogicalType&);
889 LogicalType& operator=(const LogicalType&);
890 LogicalType() {
891 }
892
893 virtual ~LogicalType() throw();
894 StringType STRING;
895 MapType MAP;
896 ListType LIST;
897 EnumType ENUM;
898 DecimalType DECIMAL;
899 DateType DATE;
900 TimeType TIME;
901 TimestampType TIMESTAMP;
902 IntType INTEGER;
903 NullType UNKNOWN;
904 JsonType JSON;
905 BsonType BSON;
906
907 _LogicalType__isset __isset;
908
909 void __set_STRING(const StringType& val);
910
911 void __set_MAP(const MapType& val);
912
913 void __set_LIST(const ListType& val);
914
915 void __set_ENUM(const EnumType& val);
916
917 void __set_DECIMAL(const DecimalType& val);
918
919 void __set_DATE(const DateType& val);
920
921 void __set_TIME(const TimeType& val);
922
923 void __set_TIMESTAMP(const TimestampType& val);
924
925 void __set_INTEGER(const IntType& val);
926
927 void __set_UNKNOWN(const NullType& val);
928
929 void __set_JSON(const JsonType& val);
930
931 void __set_BSON(const BsonType& val);
932
933 bool operator == (const LogicalType & rhs) const
934 {
935 if (__isset.STRING != rhs.__isset.STRING)
936 return false;
937 else if (__isset.STRING && !(STRING == rhs.STRING))
938 return false;
939 if (__isset.MAP != rhs.__isset.MAP)
940 return false;
941 else if (__isset.MAP && !(MAP == rhs.MAP))
942 return false;
943 if (__isset.LIST != rhs.__isset.LIST)
944 return false;
945 else if (__isset.LIST && !(LIST == rhs.LIST))
946 return false;
947 if (__isset.ENUM != rhs.__isset.ENUM)
948 return false;
949 else if (__isset.ENUM && !(ENUM == rhs.ENUM))
950 return false;
951 if (__isset.DECIMAL != rhs.__isset.DECIMAL)
952 return false;
953 else if (__isset.DECIMAL && !(DECIMAL == rhs.DECIMAL))
954 return false;
955 if (__isset.DATE != rhs.__isset.DATE)
956 return false;
957 else if (__isset.DATE && !(DATE == rhs.DATE))
958 return false;
959 if (__isset.TIME != rhs.__isset.TIME)
960 return false;
961 else if (__isset.TIME && !(TIME == rhs.TIME))
962 return false;
963 if (__isset.TIMESTAMP != rhs.__isset.TIMESTAMP)
964 return false;
965 else if (__isset.TIMESTAMP && !(TIMESTAMP == rhs.TIMESTAMP))
966 return false;
967 if (__isset.INTEGER != rhs.__isset.INTEGER)
968 return false;
969 else if (__isset.INTEGER && !(INTEGER == rhs.INTEGER))
970 return false;
971 if (__isset.UNKNOWN != rhs.__isset.UNKNOWN)
972 return false;
973 else if (__isset.UNKNOWN && !(UNKNOWN == rhs.UNKNOWN))
974 return false;
975 if (__isset.JSON != rhs.__isset.JSON)
976 return false;
977 else if (__isset.JSON && !(JSON == rhs.JSON))
978 return false;
979 if (__isset.BSON != rhs.__isset.BSON)
980 return false;
981 else if (__isset.BSON && !(BSON == rhs.BSON))
982 return false;
983 return true;
984 }
985 bool operator != (const LogicalType &rhs) const {
986 return !(*this == rhs);
987 }
988
989 bool operator < (const LogicalType & ) const;
990
991 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
992 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
993
994 virtual void printTo(std::ostream& out) const;
995};
996
997void swap(LogicalType &a, LogicalType &b);
998
999std::ostream& operator<<(std::ostream& out, const LogicalType& obj);
1000
1001typedef struct _SchemaElement__isset {
1002 _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) {}
1003 bool type :1;
1004 bool type_length :1;
1005 bool repetition_type :1;
1006 bool num_children :1;
1007 bool converted_type :1;
1008 bool scale :1;
1009 bool precision :1;
1010 bool field_id :1;
1011 bool logicalType :1;
1012} _SchemaElement__isset;
1013
1014class SchemaElement : public virtual ::apache::thrift::TBase {
1015 public:
1016
1017 SchemaElement(const SchemaElement&);
1018 SchemaElement& operator=(const SchemaElement&);
1019 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) {
1020 }
1021
1022 virtual ~SchemaElement() throw();
1023 Type::type type;
1024 int32_t type_length;
1025 FieldRepetitionType::type repetition_type;
1026 std::string name;
1027 int32_t num_children;
1028 ConvertedType::type converted_type;
1029 int32_t scale;
1030 int32_t precision;
1031 int32_t field_id;
1032 LogicalType logicalType;
1033
1034 _SchemaElement__isset __isset;
1035
1036 void __set_type(const Type::type val);
1037
1038 void __set_type_length(const int32_t val);
1039
1040 void __set_repetition_type(const FieldRepetitionType::type val);
1041
1042 void __set_name(const std::string& val);
1043
1044 void __set_num_children(const int32_t val);
1045
1046 void __set_converted_type(const ConvertedType::type val);
1047
1048 void __set_scale(const int32_t val);
1049
1050 void __set_precision(const int32_t val);
1051
1052 void __set_field_id(const int32_t val);
1053
1054 void __set_logicalType(const LogicalType& val);
1055
1056 bool operator == (const SchemaElement & rhs) const
1057 {
1058 if (__isset.type != rhs.__isset.type)
1059 return false;
1060 else if (__isset.type && !(type == rhs.type))
1061 return false;
1062 if (__isset.type_length != rhs.__isset.type_length)
1063 return false;
1064 else if (__isset.type_length && !(type_length == rhs.type_length))
1065 return false;
1066 if (__isset.repetition_type != rhs.__isset.repetition_type)
1067 return false;
1068 else if (__isset.repetition_type && !(repetition_type == rhs.repetition_type))
1069 return false;
1070 if (!(name == rhs.name))
1071 return false;
1072 if (__isset.num_children != rhs.__isset.num_children)
1073 return false;
1074 else if (__isset.num_children && !(num_children == rhs.num_children))
1075 return false;
1076 if (__isset.converted_type != rhs.__isset.converted_type)
1077 return false;
1078 else if (__isset.converted_type && !(converted_type == rhs.converted_type))
1079 return false;
1080 if (__isset.scale != rhs.__isset.scale)
1081 return false;
1082 else if (__isset.scale && !(scale == rhs.scale))
1083 return false;
1084 if (__isset.precision != rhs.__isset.precision)
1085 return false;
1086 else if (__isset.precision && !(precision == rhs.precision))
1087 return false;
1088 if (__isset.field_id != rhs.__isset.field_id)
1089 return false;
1090 else if (__isset.field_id && !(field_id == rhs.field_id))
1091 return false;
1092 if (__isset.logicalType != rhs.__isset.logicalType)
1093 return false;
1094 else if (__isset.logicalType && !(logicalType == rhs.logicalType))
1095 return false;
1096 return true;
1097 }
1098 bool operator != (const SchemaElement &rhs) const {
1099 return !(*this == rhs);
1100 }
1101
1102 bool operator < (const SchemaElement & ) const;
1103
1104 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1105 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1106
1107 virtual void printTo(std::ostream& out) const;
1108};
1109
1110void swap(SchemaElement &a, SchemaElement &b);
1111
1112std::ostream& operator<<(std::ostream& out, const SchemaElement& obj);
1113
1114typedef struct _DataPageHeader__isset {
1115 _DataPageHeader__isset() : statistics(false) {}
1116 bool statistics :1;
1117} _DataPageHeader__isset;
1118
1119class DataPageHeader : public virtual ::apache::thrift::TBase {
1120 public:
1121
1122 DataPageHeader(const DataPageHeader&);
1123 DataPageHeader& operator=(const DataPageHeader&);
1124 DataPageHeader() : num_values(0), encoding((Encoding::type)0), definition_level_encoding((Encoding::type)0), repetition_level_encoding((Encoding::type)0) {
1125 }
1126
1127 virtual ~DataPageHeader() throw();
1128 int32_t num_values;
1129 Encoding::type encoding;
1130 Encoding::type definition_level_encoding;
1131 Encoding::type repetition_level_encoding;
1132 Statistics statistics;
1133
1134 _DataPageHeader__isset __isset;
1135
1136 void __set_num_values(const int32_t val);
1137
1138 void __set_encoding(const Encoding::type val);
1139
1140 void __set_definition_level_encoding(const Encoding::type val);
1141
1142 void __set_repetition_level_encoding(const Encoding::type val);
1143
1144 void __set_statistics(const Statistics& val);
1145
1146 bool operator == (const DataPageHeader & rhs) const
1147 {
1148 if (!(num_values == rhs.num_values))
1149 return false;
1150 if (!(encoding == rhs.encoding))
1151 return false;
1152 if (!(definition_level_encoding == rhs.definition_level_encoding))
1153 return false;
1154 if (!(repetition_level_encoding == rhs.repetition_level_encoding))
1155 return false;
1156 if (__isset.statistics != rhs.__isset.statistics)
1157 return false;
1158 else if (__isset.statistics && !(statistics == rhs.statistics))
1159 return false;
1160 return true;
1161 }
1162 bool operator != (const DataPageHeader &rhs) const {
1163 return !(*this == rhs);
1164 }
1165
1166 bool operator < (const DataPageHeader & ) const;
1167
1168 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1169 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1170
1171 virtual void printTo(std::ostream& out) const;
1172};
1173
1174void swap(DataPageHeader &a, DataPageHeader &b);
1175
1176std::ostream& operator<<(std::ostream& out, const DataPageHeader& obj);
1177
1178
1179class IndexPageHeader : public virtual ::apache::thrift::TBase {
1180 public:
1181
1182 IndexPageHeader(const IndexPageHeader&);
1183 IndexPageHeader& operator=(const IndexPageHeader&);
1184 IndexPageHeader() {
1185 }
1186
1187 virtual ~IndexPageHeader() throw();
1188
1189 bool operator == (const IndexPageHeader & /* rhs */) const
1190 {
1191 return true;
1192 }
1193 bool operator != (const IndexPageHeader &rhs) const {
1194 return !(*this == rhs);
1195 }
1196
1197 bool operator < (const IndexPageHeader & ) const;
1198
1199 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1200 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1201
1202 virtual void printTo(std::ostream& out) const;
1203};
1204
1205void swap(IndexPageHeader &a, IndexPageHeader &b);
1206
1207std::ostream& operator<<(std::ostream& out, const IndexPageHeader& obj);
1208
1209typedef struct _DictionaryPageHeader__isset {
1210 _DictionaryPageHeader__isset() : is_sorted(false) {}
1211 bool is_sorted :1;
1212} _DictionaryPageHeader__isset;
1213
1214class DictionaryPageHeader : public virtual ::apache::thrift::TBase {
1215 public:
1216
1217 DictionaryPageHeader(const DictionaryPageHeader&);
1218 DictionaryPageHeader& operator=(const DictionaryPageHeader&);
1219 DictionaryPageHeader() : num_values(0), encoding((Encoding::type)0), is_sorted(0) {
1220 }
1221
1222 virtual ~DictionaryPageHeader() throw();
1223 int32_t num_values;
1224 Encoding::type encoding;
1225 bool is_sorted;
1226
1227 _DictionaryPageHeader__isset __isset;
1228
1229 void __set_num_values(const int32_t val);
1230
1231 void __set_encoding(const Encoding::type val);
1232
1233 void __set_is_sorted(const bool val);
1234
1235 bool operator == (const DictionaryPageHeader & rhs) const
1236 {
1237 if (!(num_values == rhs.num_values))
1238 return false;
1239 if (!(encoding == rhs.encoding))
1240 return false;
1241 if (__isset.is_sorted != rhs.__isset.is_sorted)
1242 return false;
1243 else if (__isset.is_sorted && !(is_sorted == rhs.is_sorted))
1244 return false;
1245 return true;
1246 }
1247 bool operator != (const DictionaryPageHeader &rhs) const {
1248 return !(*this == rhs);
1249 }
1250
1251 bool operator < (const DictionaryPageHeader & ) const;
1252
1253 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1254 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1255
1256 virtual void printTo(std::ostream& out) const;
1257};
1258
1259void swap(DictionaryPageHeader &a, DictionaryPageHeader &b);
1260
1261std::ostream& operator<<(std::ostream& out, const DictionaryPageHeader& obj);
1262
1263typedef struct _DataPageHeaderV2__isset {
1264 _DataPageHeaderV2__isset() : is_compressed(true), statistics(false) {}
1265 bool is_compressed :1;
1266 bool statistics :1;
1267} _DataPageHeaderV2__isset;
1268
1269class DataPageHeaderV2 : public virtual ::apache::thrift::TBase {
1270 public:
1271
1272 DataPageHeaderV2(const DataPageHeaderV2&);
1273 DataPageHeaderV2& operator=(const DataPageHeaderV2&);
1274 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) {
1275 }
1276
1277 virtual ~DataPageHeaderV2() throw();
1278 int32_t num_values;
1279 int32_t num_nulls;
1280 int32_t num_rows;
1281 Encoding::type encoding;
1282 int32_t definition_levels_byte_length;
1283 int32_t repetition_levels_byte_length;
1284 bool is_compressed;
1285 Statistics statistics;
1286
1287 _DataPageHeaderV2__isset __isset;
1288
1289 void __set_num_values(const int32_t val);
1290
1291 void __set_num_nulls(const int32_t val);
1292
1293 void __set_num_rows(const int32_t val);
1294
1295 void __set_encoding(const Encoding::type val);
1296
1297 void __set_definition_levels_byte_length(const int32_t val);
1298
1299 void __set_repetition_levels_byte_length(const int32_t val);
1300
1301 void __set_is_compressed(const bool val);
1302
1303 void __set_statistics(const Statistics& val);
1304
1305 bool operator == (const DataPageHeaderV2 & rhs) const
1306 {
1307 if (!(num_values == rhs.num_values))
1308 return false;
1309 if (!(num_nulls == rhs.num_nulls))
1310 return false;
1311 if (!(num_rows == rhs.num_rows))
1312 return false;
1313 if (!(encoding == rhs.encoding))
1314 return false;
1315 if (!(definition_levels_byte_length == rhs.definition_levels_byte_length))
1316 return false;
1317 if (!(repetition_levels_byte_length == rhs.repetition_levels_byte_length))
1318 return false;
1319 if (__isset.is_compressed != rhs.__isset.is_compressed)
1320 return false;
1321 else if (__isset.is_compressed && !(is_compressed == rhs.is_compressed))
1322 return false;
1323 if (__isset.statistics != rhs.__isset.statistics)
1324 return false;
1325 else if (__isset.statistics && !(statistics == rhs.statistics))
1326 return false;
1327 return true;
1328 }
1329 bool operator != (const DataPageHeaderV2 &rhs) const {
1330 return !(*this == rhs);
1331 }
1332
1333 bool operator < (const DataPageHeaderV2 & ) const;
1334
1335 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1336 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1337
1338 virtual void printTo(std::ostream& out) const;
1339};
1340
1341void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b);
1342
1343std::ostream& operator<<(std::ostream& out, const DataPageHeaderV2& obj);
1344
1345typedef struct _PageHeader__isset {
1346 _PageHeader__isset() : crc(false), data_page_header(false), index_page_header(false), dictionary_page_header(false), data_page_header_v2(false) {}
1347 bool crc :1;
1348 bool data_page_header :1;
1349 bool index_page_header :1;
1350 bool dictionary_page_header :1;
1351 bool data_page_header_v2 :1;
1352} _PageHeader__isset;
1353
1354class PageHeader : public virtual ::apache::thrift::TBase {
1355 public:
1356
1357 PageHeader(const PageHeader&);
1358 PageHeader& operator=(const PageHeader&);
1359 PageHeader() : type((PageType::type)0), uncompressed_page_size(0), compressed_page_size(0), crc(0) {
1360 }
1361
1362 virtual ~PageHeader() throw();
1363 PageType::type type;
1364 int32_t uncompressed_page_size;
1365 int32_t compressed_page_size;
1366 int32_t crc;
1367 DataPageHeader data_page_header;
1368 IndexPageHeader index_page_header;
1369 DictionaryPageHeader dictionary_page_header;
1370 DataPageHeaderV2 data_page_header_v2;
1371
1372 _PageHeader__isset __isset;
1373
1374 void __set_type(const PageType::type val);
1375
1376 void __set_uncompressed_page_size(const int32_t val);
1377
1378 void __set_compressed_page_size(const int32_t val);
1379
1380 void __set_crc(const int32_t val);
1381
1382 void __set_data_page_header(const DataPageHeader& val);
1383
1384 void __set_index_page_header(const IndexPageHeader& val);
1385
1386 void __set_dictionary_page_header(const DictionaryPageHeader& val);
1387
1388 void __set_data_page_header_v2(const DataPageHeaderV2& val);
1389
1390 bool operator == (const PageHeader & rhs) const
1391 {
1392 if (!(type == rhs.type))
1393 return false;
1394 if (!(uncompressed_page_size == rhs.uncompressed_page_size))
1395 return false;
1396 if (!(compressed_page_size == rhs.compressed_page_size))
1397 return false;
1398 if (__isset.crc != rhs.__isset.crc)
1399 return false;
1400 else if (__isset.crc && !(crc == rhs.crc))
1401 return false;
1402 if (__isset.data_page_header != rhs.__isset.data_page_header)
1403 return false;
1404 else if (__isset.data_page_header && !(data_page_header == rhs.data_page_header))
1405 return false;
1406 if (__isset.index_page_header != rhs.__isset.index_page_header)
1407 return false;
1408 else if (__isset.index_page_header && !(index_page_header == rhs.index_page_header))
1409 return false;
1410 if (__isset.dictionary_page_header != rhs.__isset.dictionary_page_header)
1411 return false;
1412 else if (__isset.dictionary_page_header && !(dictionary_page_header == rhs.dictionary_page_header))
1413 return false;
1414 if (__isset.data_page_header_v2 != rhs.__isset.data_page_header_v2)
1415 return false;
1416 else if (__isset.data_page_header_v2 && !(data_page_header_v2 == rhs.data_page_header_v2))
1417 return false;
1418 return true;
1419 }
1420 bool operator != (const PageHeader &rhs) const {
1421 return !(*this == rhs);
1422 }
1423
1424 bool operator < (const PageHeader & ) const;
1425
1426 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1427 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1428
1429 virtual void printTo(std::ostream& out) const;
1430};
1431
1432void swap(PageHeader &a, PageHeader &b);
1433
1434std::ostream& operator<<(std::ostream& out, const PageHeader& obj);
1435
1436typedef struct _KeyValue__isset {
1437 _KeyValue__isset() : value(false) {}
1438 bool value :1;
1439} _KeyValue__isset;
1440
1441class KeyValue : public virtual ::apache::thrift::TBase {
1442 public:
1443
1444 KeyValue(const KeyValue&);
1445 KeyValue& operator=(const KeyValue&);
1446 KeyValue() : key(), value() {
1447 }
1448
1449 virtual ~KeyValue() throw();
1450 std::string key;
1451 std::string value;
1452
1453 _KeyValue__isset __isset;
1454
1455 void __set_key(const std::string& val);
1456
1457 void __set_value(const std::string& val);
1458
1459 bool operator == (const KeyValue & rhs) const
1460 {
1461 if (!(key == rhs.key))
1462 return false;
1463 if (__isset.value != rhs.__isset.value)
1464 return false;
1465 else if (__isset.value && !(value == rhs.value))
1466 return false;
1467 return true;
1468 }
1469 bool operator != (const KeyValue &rhs) const {
1470 return !(*this == rhs);
1471 }
1472
1473 bool operator < (const KeyValue & ) const;
1474
1475 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1476 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1477
1478 virtual void printTo(std::ostream& out) const;
1479};
1480
1481void swap(KeyValue &a, KeyValue &b);
1482
1483std::ostream& operator<<(std::ostream& out, const KeyValue& obj);
1484
1485
1486class SortingColumn : public virtual ::apache::thrift::TBase {
1487 public:
1488
1489 SortingColumn(const SortingColumn&);
1490 SortingColumn& operator=(const SortingColumn&);
1491 SortingColumn() : column_idx(0), descending(0), nulls_first(0) {
1492 }
1493
1494 virtual ~SortingColumn() throw();
1495 int32_t column_idx;
1496 bool descending;
1497 bool nulls_first;
1498
1499 void __set_column_idx(const int32_t val);
1500
1501 void __set_descending(const bool val);
1502
1503 void __set_nulls_first(const bool val);
1504
1505 bool operator == (const SortingColumn & rhs) const
1506 {
1507 if (!(column_idx == rhs.column_idx))
1508 return false;
1509 if (!(descending == rhs.descending))
1510 return false;
1511 if (!(nulls_first == rhs.nulls_first))
1512 return false;
1513 return true;
1514 }
1515 bool operator != (const SortingColumn &rhs) const {
1516 return !(*this == rhs);
1517 }
1518
1519 bool operator < (const SortingColumn & ) const;
1520
1521 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1522 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1523
1524 virtual void printTo(std::ostream& out) const;
1525};
1526
1527void swap(SortingColumn &a, SortingColumn &b);
1528
1529std::ostream& operator<<(std::ostream& out, const SortingColumn& obj);
1530
1531
1532class PageEncodingStats : public virtual ::apache::thrift::TBase {
1533 public:
1534
1535 PageEncodingStats(const PageEncodingStats&);
1536 PageEncodingStats& operator=(const PageEncodingStats&);
1537 PageEncodingStats() : page_type((PageType::type)0), encoding((Encoding::type)0), count(0) {
1538 }
1539
1540 virtual ~PageEncodingStats() throw();
1541 PageType::type page_type;
1542 Encoding::type encoding;
1543 int32_t count;
1544
1545 void __set_page_type(const PageType::type val);
1546
1547 void __set_encoding(const Encoding::type val);
1548
1549 void __set_count(const int32_t val);
1550
1551 bool operator == (const PageEncodingStats & rhs) const
1552 {
1553 if (!(page_type == rhs.page_type))
1554 return false;
1555 if (!(encoding == rhs.encoding))
1556 return false;
1557 if (!(count == rhs.count))
1558 return false;
1559 return true;
1560 }
1561 bool operator != (const PageEncodingStats &rhs) const {
1562 return !(*this == rhs);
1563 }
1564
1565 bool operator < (const PageEncodingStats & ) const;
1566
1567 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1568 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1569
1570 virtual void printTo(std::ostream& out) const;
1571};
1572
1573void swap(PageEncodingStats &a, PageEncodingStats &b);
1574
1575std::ostream& operator<<(std::ostream& out, const PageEncodingStats& obj);
1576
1577typedef struct _ColumnMetaData__isset {
1578 _ColumnMetaData__isset() : key_value_metadata(false), index_page_offset(false), dictionary_page_offset(false), statistics(false), encoding_stats(false) {}
1579 bool key_value_metadata :1;
1580 bool index_page_offset :1;
1581 bool dictionary_page_offset :1;
1582 bool statistics :1;
1583 bool encoding_stats :1;
1584} _ColumnMetaData__isset;
1585
1586class ColumnMetaData : public virtual ::apache::thrift::TBase {
1587 public:
1588
1589 ColumnMetaData(const ColumnMetaData&);
1590 ColumnMetaData& operator=(const ColumnMetaData&);
1591 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) {
1592 }
1593
1594 virtual ~ColumnMetaData() throw();
1595 Type::type type;
1596 std::vector<Encoding::type> encodings;
1597 std::vector<std::string> path_in_schema;
1598 CompressionCodec::type codec;
1599 int64_t num_values;
1600 int64_t total_uncompressed_size;
1601 int64_t total_compressed_size;
1602 std::vector<KeyValue> key_value_metadata;
1603 int64_t data_page_offset;
1604 int64_t index_page_offset;
1605 int64_t dictionary_page_offset;
1606 Statistics statistics;
1607 std::vector<PageEncodingStats> encoding_stats;
1608
1609 _ColumnMetaData__isset __isset;
1610
1611 void __set_type(const Type::type val);
1612
1613 void __set_encodings(const std::vector<Encoding::type> & val);
1614
1615 void __set_path_in_schema(const std::vector<std::string> & val);
1616
1617 void __set_codec(const CompressionCodec::type val);
1618
1619 void __set_num_values(const int64_t val);
1620
1621 void __set_total_uncompressed_size(const int64_t val);
1622
1623 void __set_total_compressed_size(const int64_t val);
1624
1625 void __set_key_value_metadata(const std::vector<KeyValue> & val);
1626
1627 void __set_data_page_offset(const int64_t val);
1628
1629 void __set_index_page_offset(const int64_t val);
1630
1631 void __set_dictionary_page_offset(const int64_t val);
1632
1633 void __set_statistics(const Statistics& val);
1634
1635 void __set_encoding_stats(const std::vector<PageEncodingStats> & val);
1636
1637 bool operator == (const ColumnMetaData & rhs) const
1638 {
1639 if (!(type == rhs.type))
1640 return false;
1641 if (!(encodings == rhs.encodings))
1642 return false;
1643 if (!(path_in_schema == rhs.path_in_schema))
1644 return false;
1645 if (!(codec == rhs.codec))
1646 return false;
1647 if (!(num_values == rhs.num_values))
1648 return false;
1649 if (!(total_uncompressed_size == rhs.total_uncompressed_size))
1650 return false;
1651 if (!(total_compressed_size == rhs.total_compressed_size))
1652 return false;
1653 if (__isset.key_value_metadata != rhs.__isset.key_value_metadata)
1654 return false;
1655 else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata))
1656 return false;
1657 if (!(data_page_offset == rhs.data_page_offset))
1658 return false;
1659 if (__isset.index_page_offset != rhs.__isset.index_page_offset)
1660 return false;
1661 else if (__isset.index_page_offset && !(index_page_offset == rhs.index_page_offset))
1662 return false;
1663 if (__isset.dictionary_page_offset != rhs.__isset.dictionary_page_offset)
1664 return false;
1665 else if (__isset.dictionary_page_offset && !(dictionary_page_offset == rhs.dictionary_page_offset))
1666 return false;
1667 if (__isset.statistics != rhs.__isset.statistics)
1668 return false;
1669 else if (__isset.statistics && !(statistics == rhs.statistics))
1670 return false;
1671 if (__isset.encoding_stats != rhs.__isset.encoding_stats)
1672 return false;
1673 else if (__isset.encoding_stats && !(encoding_stats == rhs.encoding_stats))
1674 return false;
1675 return true;
1676 }
1677 bool operator != (const ColumnMetaData &rhs) const {
1678 return !(*this == rhs);
1679 }
1680
1681 bool operator < (const ColumnMetaData & ) const;
1682
1683 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1684 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1685
1686 virtual void printTo(std::ostream& out) const;
1687};
1688
1689void swap(ColumnMetaData &a, ColumnMetaData &b);
1690
1691std::ostream& operator<<(std::ostream& out, const ColumnMetaData& obj);
1692
1693
1694class EncryptionWithFooterKey : public virtual ::apache::thrift::TBase {
1695 public:
1696
1697 EncryptionWithFooterKey(const EncryptionWithFooterKey&);
1698 EncryptionWithFooterKey& operator=(const EncryptionWithFooterKey&);
1699 EncryptionWithFooterKey() {
1700 }
1701
1702 virtual ~EncryptionWithFooterKey() throw();
1703
1704 bool operator == (const EncryptionWithFooterKey & /* rhs */) const
1705 {
1706 return true;
1707 }
1708 bool operator != (const EncryptionWithFooterKey &rhs) const {
1709 return !(*this == rhs);
1710 }
1711
1712 bool operator < (const EncryptionWithFooterKey & ) const;
1713
1714 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1715 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1716
1717 virtual void printTo(std::ostream& out) const;
1718};
1719
1720void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b);
1721
1722std::ostream& operator<<(std::ostream& out, const EncryptionWithFooterKey& obj);
1723
1724typedef struct _EncryptionWithColumnKey__isset {
1725 _EncryptionWithColumnKey__isset() : column_key_metadata(false) {}
1726 bool column_key_metadata :1;
1727} _EncryptionWithColumnKey__isset;
1728
1729class EncryptionWithColumnKey : public virtual ::apache::thrift::TBase {
1730 public:
1731
1732 EncryptionWithColumnKey(const EncryptionWithColumnKey&);
1733 EncryptionWithColumnKey& operator=(const EncryptionWithColumnKey&);
1734 EncryptionWithColumnKey() : column_key_metadata() {
1735 }
1736
1737 virtual ~EncryptionWithColumnKey() throw();
1738 std::vector<std::string> path_in_schema;
1739 std::string column_key_metadata;
1740
1741 _EncryptionWithColumnKey__isset __isset;
1742
1743 void __set_path_in_schema(const std::vector<std::string> & val);
1744
1745 void __set_column_key_metadata(const std::string& val);
1746
1747 bool operator == (const EncryptionWithColumnKey & rhs) const
1748 {
1749 if (!(path_in_schema == rhs.path_in_schema))
1750 return false;
1751 if (__isset.column_key_metadata != rhs.__isset.column_key_metadata)
1752 return false;
1753 else if (__isset.column_key_metadata && !(column_key_metadata == rhs.column_key_metadata))
1754 return false;
1755 return true;
1756 }
1757 bool operator != (const EncryptionWithColumnKey &rhs) const {
1758 return !(*this == rhs);
1759 }
1760
1761 bool operator < (const EncryptionWithColumnKey & ) const;
1762
1763 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1764 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1765
1766 virtual void printTo(std::ostream& out) const;
1767};
1768
1769void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b);
1770
1771std::ostream& operator<<(std::ostream& out, const EncryptionWithColumnKey& obj);
1772
1773typedef struct _ColumnCryptoMetaData__isset {
1774 _ColumnCryptoMetaData__isset() : ENCRYPTION_WITH_FOOTER_KEY(false), ENCRYPTION_WITH_COLUMN_KEY(false) {}
1775 bool ENCRYPTION_WITH_FOOTER_KEY :1;
1776 bool ENCRYPTION_WITH_COLUMN_KEY :1;
1777} _ColumnCryptoMetaData__isset;
1778
1779class ColumnCryptoMetaData : public virtual ::apache::thrift::TBase {
1780 public:
1781
1782 ColumnCryptoMetaData(const ColumnCryptoMetaData&);
1783 ColumnCryptoMetaData& operator=(const ColumnCryptoMetaData&);
1784 ColumnCryptoMetaData() {
1785 }
1786
1787 virtual ~ColumnCryptoMetaData() throw();
1788 EncryptionWithFooterKey ENCRYPTION_WITH_FOOTER_KEY;
1789 EncryptionWithColumnKey ENCRYPTION_WITH_COLUMN_KEY;
1790
1791 _ColumnCryptoMetaData__isset __isset;
1792
1793 void __set_ENCRYPTION_WITH_FOOTER_KEY(const EncryptionWithFooterKey& val);
1794
1795 void __set_ENCRYPTION_WITH_COLUMN_KEY(const EncryptionWithColumnKey& val);
1796
1797 bool operator == (const ColumnCryptoMetaData & rhs) const
1798 {
1799 if (__isset.ENCRYPTION_WITH_FOOTER_KEY != rhs.__isset.ENCRYPTION_WITH_FOOTER_KEY)
1800 return false;
1801 else if (__isset.ENCRYPTION_WITH_FOOTER_KEY && !(ENCRYPTION_WITH_FOOTER_KEY == rhs.ENCRYPTION_WITH_FOOTER_KEY))
1802 return false;
1803 if (__isset.ENCRYPTION_WITH_COLUMN_KEY != rhs.__isset.ENCRYPTION_WITH_COLUMN_KEY)
1804 return false;
1805 else if (__isset.ENCRYPTION_WITH_COLUMN_KEY && !(ENCRYPTION_WITH_COLUMN_KEY == rhs.ENCRYPTION_WITH_COLUMN_KEY))
1806 return false;
1807 return true;
1808 }
1809 bool operator != (const ColumnCryptoMetaData &rhs) const {
1810 return !(*this == rhs);
1811 }
1812
1813 bool operator < (const ColumnCryptoMetaData & ) const;
1814
1815 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1816 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1817
1818 virtual void printTo(std::ostream& out) const;
1819};
1820
1821void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b);
1822
1823std::ostream& operator<<(std::ostream& out, const ColumnCryptoMetaData& obj);
1824
1825typedef struct _ColumnChunk__isset {
1826 _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_meta_data(false) {}
1827 bool file_path :1;
1828 bool meta_data :1;
1829 bool offset_index_offset :1;
1830 bool offset_index_length :1;
1831 bool column_index_offset :1;
1832 bool column_index_length :1;
1833 bool crypto_meta_data :1;
1834} _ColumnChunk__isset;
1835
1836class ColumnChunk : public virtual ::apache::thrift::TBase {
1837 public:
1838
1839 ColumnChunk(const ColumnChunk&);
1840 ColumnChunk& operator=(const ColumnChunk&);
1841 ColumnChunk() : file_path(), file_offset(0), offset_index_offset(0), offset_index_length(0), column_index_offset(0), column_index_length(0) {
1842 }
1843
1844 virtual ~ColumnChunk() throw();
1845 std::string file_path;
1846 int64_t file_offset;
1847 ColumnMetaData meta_data;
1848 int64_t offset_index_offset;
1849 int32_t offset_index_length;
1850 int64_t column_index_offset;
1851 int32_t column_index_length;
1852 ColumnCryptoMetaData crypto_meta_data;
1853
1854 _ColumnChunk__isset __isset;
1855
1856 void __set_file_path(const std::string& val);
1857
1858 void __set_file_offset(const int64_t val);
1859
1860 void __set_meta_data(const ColumnMetaData& val);
1861
1862 void __set_offset_index_offset(const int64_t val);
1863
1864 void __set_offset_index_length(const int32_t val);
1865
1866 void __set_column_index_offset(const int64_t val);
1867
1868 void __set_column_index_length(const int32_t val);
1869
1870 void __set_crypto_meta_data(const ColumnCryptoMetaData& val);
1871
1872 bool operator == (const ColumnChunk & rhs) const
1873 {
1874 if (__isset.file_path != rhs.__isset.file_path)
1875 return false;
1876 else if (__isset.file_path && !(file_path == rhs.file_path))
1877 return false;
1878 if (!(file_offset == rhs.file_offset))
1879 return false;
1880 if (__isset.meta_data != rhs.__isset.meta_data)
1881 return false;
1882 else if (__isset.meta_data && !(meta_data == rhs.meta_data))
1883 return false;
1884 if (__isset.offset_index_offset != rhs.__isset.offset_index_offset)
1885 return false;
1886 else if (__isset.offset_index_offset && !(offset_index_offset == rhs.offset_index_offset))
1887 return false;
1888 if (__isset.offset_index_length != rhs.__isset.offset_index_length)
1889 return false;
1890 else if (__isset.offset_index_length && !(offset_index_length == rhs.offset_index_length))
1891 return false;
1892 if (__isset.column_index_offset != rhs.__isset.column_index_offset)
1893 return false;
1894 else if (__isset.column_index_offset && !(column_index_offset == rhs.column_index_offset))
1895 return false;
1896 if (__isset.column_index_length != rhs.__isset.column_index_length)
1897 return false;
1898 else if (__isset.column_index_length && !(column_index_length == rhs.column_index_length))
1899 return false;
1900 if (__isset.crypto_meta_data != rhs.__isset.crypto_meta_data)
1901 return false;
1902 else if (__isset.crypto_meta_data && !(crypto_meta_data == rhs.crypto_meta_data))
1903 return false;
1904 return true;
1905 }
1906 bool operator != (const ColumnChunk &rhs) const {
1907 return !(*this == rhs);
1908 }
1909
1910 bool operator < (const ColumnChunk & ) const;
1911
1912 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1913 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1914
1915 virtual void printTo(std::ostream& out) const;
1916};
1917
1918void swap(ColumnChunk &a, ColumnChunk &b);
1919
1920std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj);
1921
1922typedef struct _RowGroup__isset {
1923 _RowGroup__isset() : sorting_columns(false), file_offset(false), total_compressed_size(false) {}
1924 bool sorting_columns :1;
1925 bool file_offset :1;
1926 bool total_compressed_size :1;
1927} _RowGroup__isset;
1928
1929class RowGroup : public virtual ::apache::thrift::TBase {
1930 public:
1931
1932 RowGroup(const RowGroup&);
1933 RowGroup& operator=(const RowGroup&);
1934 RowGroup() : total_byte_size(0), num_rows(0), file_offset(0), total_compressed_size(0) {
1935 }
1936
1937 virtual ~RowGroup() throw();
1938 std::vector<ColumnChunk> columns;
1939 int64_t total_byte_size;
1940 int64_t num_rows;
1941 std::vector<SortingColumn> sorting_columns;
1942 int64_t file_offset;
1943 int64_t total_compressed_size;
1944
1945 _RowGroup__isset __isset;
1946
1947 void __set_columns(const std::vector<ColumnChunk> & val);
1948
1949 void __set_total_byte_size(const int64_t val);
1950
1951 void __set_num_rows(const int64_t val);
1952
1953 void __set_sorting_columns(const std::vector<SortingColumn> & val);
1954
1955 void __set_file_offset(const int64_t val);
1956
1957 void __set_total_compressed_size(const int64_t val);
1958
1959 bool operator == (const RowGroup & rhs) const
1960 {
1961 if (!(columns == rhs.columns))
1962 return false;
1963 if (!(total_byte_size == rhs.total_byte_size))
1964 return false;
1965 if (!(num_rows == rhs.num_rows))
1966 return false;
1967 if (__isset.sorting_columns != rhs.__isset.sorting_columns)
1968 return false;
1969 else if (__isset.sorting_columns && !(sorting_columns == rhs.sorting_columns))
1970 return false;
1971 if (__isset.file_offset != rhs.__isset.file_offset)
1972 return false;
1973 else if (__isset.file_offset && !(file_offset == rhs.file_offset))
1974 return false;
1975 if (__isset.total_compressed_size != rhs.__isset.total_compressed_size)
1976 return false;
1977 else if (__isset.total_compressed_size && !(total_compressed_size == rhs.total_compressed_size))
1978 return false;
1979 return true;
1980 }
1981 bool operator != (const RowGroup &rhs) const {
1982 return !(*this == rhs);
1983 }
1984
1985 bool operator < (const RowGroup & ) const;
1986
1987 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1988 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1989
1990 virtual void printTo(std::ostream& out) const;
1991};
1992
1993void swap(RowGroup &a, RowGroup &b);
1994
1995std::ostream& operator<<(std::ostream& out, const RowGroup& obj);
1996
1997
1998class TypeDefinedOrder : public virtual ::apache::thrift::TBase {
1999 public:
2000
2001 TypeDefinedOrder(const TypeDefinedOrder&);
2002 TypeDefinedOrder& operator=(const TypeDefinedOrder&);
2003 TypeDefinedOrder() {
2004 }
2005
2006 virtual ~TypeDefinedOrder() throw();
2007
2008 bool operator == (const TypeDefinedOrder & /* rhs */) const
2009 {
2010 return true;
2011 }
2012 bool operator != (const TypeDefinedOrder &rhs) const {
2013 return !(*this == rhs);
2014 }
2015
2016 bool operator < (const TypeDefinedOrder & ) const;
2017
2018 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2019 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2020
2021 virtual void printTo(std::ostream& out) const;
2022};
2023
2024void swap(TypeDefinedOrder &a, TypeDefinedOrder &b);
2025
2026std::ostream& operator<<(std::ostream& out, const TypeDefinedOrder& obj);
2027
2028typedef struct _ColumnOrder__isset {
2029 _ColumnOrder__isset() : TYPE_ORDER(false) {}
2030 bool TYPE_ORDER :1;
2031} _ColumnOrder__isset;
2032
2033class ColumnOrder : public virtual ::apache::thrift::TBase {
2034 public:
2035
2036 ColumnOrder(const ColumnOrder&);
2037 ColumnOrder& operator=(const ColumnOrder&);
2038 ColumnOrder() {
2039 }
2040
2041 virtual ~ColumnOrder() throw();
2042 TypeDefinedOrder TYPE_ORDER;
2043
2044 _ColumnOrder__isset __isset;
2045
2046 void __set_TYPE_ORDER(const TypeDefinedOrder& val);
2047
2048 bool operator == (const ColumnOrder & rhs) const
2049 {
2050 if (__isset.TYPE_ORDER != rhs.__isset.TYPE_ORDER)
2051 return false;
2052 else if (__isset.TYPE_ORDER && !(TYPE_ORDER == rhs.TYPE_ORDER))
2053 return false;
2054 return true;
2055 }
2056 bool operator != (const ColumnOrder &rhs) const {
2057 return !(*this == rhs);
2058 }
2059
2060 bool operator < (const ColumnOrder & ) const;
2061
2062 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2063 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2064
2065 virtual void printTo(std::ostream& out) const;
2066};
2067
2068void swap(ColumnOrder &a, ColumnOrder &b);
2069
2070std::ostream& operator<<(std::ostream& out, const ColumnOrder& obj);
2071
2072
2073class PageLocation : public virtual ::apache::thrift::TBase {
2074 public:
2075
2076 PageLocation(const PageLocation&);
2077 PageLocation& operator=(const PageLocation&);
2078 PageLocation() : offset(0), compressed_page_size(0), first_row_index(0) {
2079 }
2080
2081 virtual ~PageLocation() throw();
2082 int64_t offset;
2083 int32_t compressed_page_size;
2084 int64_t first_row_index;
2085
2086 void __set_offset(const int64_t val);
2087
2088 void __set_compressed_page_size(const int32_t val);
2089
2090 void __set_first_row_index(const int64_t val);
2091
2092 bool operator == (const PageLocation & rhs) const
2093 {
2094 if (!(offset == rhs.offset))
2095 return false;
2096 if (!(compressed_page_size == rhs.compressed_page_size))
2097 return false;
2098 if (!(first_row_index == rhs.first_row_index))
2099 return false;
2100 return true;
2101 }
2102 bool operator != (const PageLocation &rhs) const {
2103 return !(*this == rhs);
2104 }
2105
2106 bool operator < (const PageLocation & ) const;
2107
2108 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2109 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2110
2111 virtual void printTo(std::ostream& out) const;
2112};
2113
2114void swap(PageLocation &a, PageLocation &b);
2115
2116std::ostream& operator<<(std::ostream& out, const PageLocation& obj);
2117
2118
2119class OffsetIndex : public virtual ::apache::thrift::TBase {
2120 public:
2121
2122 OffsetIndex(const OffsetIndex&);
2123 OffsetIndex& operator=(const OffsetIndex&);
2124 OffsetIndex() {
2125 }
2126
2127 virtual ~OffsetIndex() throw();
2128 std::vector<PageLocation> page_locations;
2129
2130 void __set_page_locations(const std::vector<PageLocation> & val);
2131
2132 bool operator == (const OffsetIndex & rhs) const
2133 {
2134 if (!(page_locations == rhs.page_locations))
2135 return false;
2136 return true;
2137 }
2138 bool operator != (const OffsetIndex &rhs) const {
2139 return !(*this == rhs);
2140 }
2141
2142 bool operator < (const OffsetIndex & ) const;
2143
2144 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2145 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2146
2147 virtual void printTo(std::ostream& out) const;
2148};
2149
2150void swap(OffsetIndex &a, OffsetIndex &b);
2151
2152std::ostream& operator<<(std::ostream& out, const OffsetIndex& obj);
2153
2154typedef struct _ColumnIndex__isset {
2155 _ColumnIndex__isset() : null_counts(false) {}
2156 bool null_counts :1;
2157} _ColumnIndex__isset;
2158
2159class ColumnIndex : public virtual ::apache::thrift::TBase {
2160 public:
2161
2162 ColumnIndex(const ColumnIndex&);
2163 ColumnIndex& operator=(const ColumnIndex&);
2164 ColumnIndex() : boundary_order((BoundaryOrder::type)0) {
2165 }
2166
2167 virtual ~ColumnIndex() throw();
2168 std::vector<bool> null_pages;
2169 std::vector<std::string> min_values;
2170 std::vector<std::string> max_values;
2171 BoundaryOrder::type boundary_order;
2172 std::vector<int64_t> null_counts;
2173
2174 _ColumnIndex__isset __isset;
2175
2176 void __set_null_pages(const std::vector<bool> & val);
2177
2178 void __set_min_values(const std::vector<std::string> & val);
2179
2180 void __set_max_values(const std::vector<std::string> & val);
2181
2182 void __set_boundary_order(const BoundaryOrder::type val);
2183
2184 void __set_null_counts(const std::vector<int64_t> & val);
2185
2186 bool operator == (const ColumnIndex & rhs) const
2187 {
2188 if (!(null_pages == rhs.null_pages))
2189 return false;
2190 if (!(min_values == rhs.min_values))
2191 return false;
2192 if (!(max_values == rhs.max_values))
2193 return false;
2194 if (!(boundary_order == rhs.boundary_order))
2195 return false;
2196 if (__isset.null_counts != rhs.__isset.null_counts)
2197 return false;
2198 else if (__isset.null_counts && !(null_counts == rhs.null_counts))
2199 return false;
2200 return true;
2201 }
2202 bool operator != (const ColumnIndex &rhs) const {
2203 return !(*this == rhs);
2204 }
2205
2206 bool operator < (const ColumnIndex & ) const;
2207
2208 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2209 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2210
2211 virtual void printTo(std::ostream& out) const;
2212};
2213
2214void swap(ColumnIndex &a, ColumnIndex &b);
2215
2216std::ostream& operator<<(std::ostream& out, const ColumnIndex& obj);
2217
2218typedef struct _FileMetaData__isset {
2219 _FileMetaData__isset() : key_value_metadata(false), created_by(false), column_orders(false) {}
2220 bool key_value_metadata :1;
2221 bool created_by :1;
2222 bool column_orders :1;
2223} _FileMetaData__isset;
2224
2225class FileMetaData : public virtual ::apache::thrift::TBase {
2226 public:
2227
2228 FileMetaData(const FileMetaData&);
2229 FileMetaData& operator=(const FileMetaData&);
2230 FileMetaData() : version(0), num_rows(0), created_by() {
2231 }
2232
2233 virtual ~FileMetaData() throw();
2234 int32_t version;
2235 std::vector<SchemaElement> schema;
2236 int64_t num_rows;
2237 std::vector<RowGroup> row_groups;
2238 std::vector<KeyValue> key_value_metadata;
2239 std::string created_by;
2240 std::vector<ColumnOrder> column_orders;
2241
2242 _FileMetaData__isset __isset;
2243
2244 void __set_version(const int32_t val);
2245
2246 void __set_schema(const std::vector<SchemaElement> & val);
2247
2248 void __set_num_rows(const int64_t val);
2249
2250 void __set_row_groups(const std::vector<RowGroup> & val);
2251
2252 void __set_key_value_metadata(const std::vector<KeyValue> & val);
2253
2254 void __set_created_by(const std::string& val);
2255
2256 void __set_column_orders(const std::vector<ColumnOrder> & val);
2257
2258 bool operator == (const FileMetaData & rhs) const
2259 {
2260 if (!(version == rhs.version))
2261 return false;
2262 if (!(schema == rhs.schema))
2263 return false;
2264 if (!(num_rows == rhs.num_rows))
2265 return false;
2266 if (!(row_groups == rhs.row_groups))
2267 return false;
2268 if (__isset.key_value_metadata != rhs.__isset.key_value_metadata)
2269 return false;
2270 else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata))
2271 return false;
2272 if (__isset.created_by != rhs.__isset.created_by)
2273 return false;
2274 else if (__isset.created_by && !(created_by == rhs.created_by))
2275 return false;
2276 if (__isset.column_orders != rhs.__isset.column_orders)
2277 return false;
2278 else if (__isset.column_orders && !(column_orders == rhs.column_orders))
2279 return false;
2280 return true;
2281 }
2282 bool operator != (const FileMetaData &rhs) const {
2283 return !(*this == rhs);
2284 }
2285
2286 bool operator < (const FileMetaData & ) const;
2287
2288 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2289 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2290
2291 virtual void printTo(std::ostream& out) const;
2292};
2293
2294void swap(FileMetaData &a, FileMetaData &b);
2295
2296std::ostream& operator<<(std::ostream& out, const FileMetaData& obj);
2297
2298typedef struct _AesGcmV1__isset {
2299 _AesGcmV1__isset() : aad_metadata(false), iv_prefix(false) {}
2300 bool aad_metadata :1;
2301 bool iv_prefix :1;
2302} _AesGcmV1__isset;
2303
2304class AesGcmV1 : public virtual ::apache::thrift::TBase {
2305 public:
2306
2307 AesGcmV1(const AesGcmV1&);
2308 AesGcmV1& operator=(const AesGcmV1&);
2309 AesGcmV1() : aad_metadata(), iv_prefix() {
2310 }
2311
2312 virtual ~AesGcmV1() throw();
2313 std::string aad_metadata;
2314 std::string iv_prefix;
2315
2316 _AesGcmV1__isset __isset;
2317
2318 void __set_aad_metadata(const std::string& val);
2319
2320 void __set_iv_prefix(const std::string& val);
2321
2322 bool operator == (const AesGcmV1 & rhs) const
2323 {
2324 if (__isset.aad_metadata != rhs.__isset.aad_metadata)
2325 return false;
2326 else if (__isset.aad_metadata && !(aad_metadata == rhs.aad_metadata))
2327 return false;
2328 if (__isset.iv_prefix != rhs.__isset.iv_prefix)
2329 return false;
2330 else if (__isset.iv_prefix && !(iv_prefix == rhs.iv_prefix))
2331 return false;
2332 return true;
2333 }
2334 bool operator != (const AesGcmV1 &rhs) const {
2335 return !(*this == rhs);
2336 }
2337
2338 bool operator < (const AesGcmV1 & ) const;
2339
2340 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2341 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2342
2343 virtual void printTo(std::ostream& out) const;
2344};
2345
2346void swap(AesGcmV1 &a, AesGcmV1 &b);
2347
2348std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj);
2349
2350typedef struct _AesGcmCtrV1__isset {
2351 _AesGcmCtrV1__isset() : aad_metadata(false), gcm_iv_prefix(false), ctr_iv_prefix(false) {}
2352 bool aad_metadata :1;
2353 bool gcm_iv_prefix :1;
2354 bool ctr_iv_prefix :1;
2355} _AesGcmCtrV1__isset;
2356
2357class AesGcmCtrV1 : public virtual ::apache::thrift::TBase {
2358 public:
2359
2360 AesGcmCtrV1(const AesGcmCtrV1&);
2361 AesGcmCtrV1& operator=(const AesGcmCtrV1&);
2362 AesGcmCtrV1() : aad_metadata(), gcm_iv_prefix(), ctr_iv_prefix() {
2363 }
2364
2365 virtual ~AesGcmCtrV1() throw();
2366 std::string aad_metadata;
2367 std::string gcm_iv_prefix;
2368 std::string ctr_iv_prefix;
2369
2370 _AesGcmCtrV1__isset __isset;
2371
2372 void __set_aad_metadata(const std::string& val);
2373
2374 void __set_gcm_iv_prefix(const std::string& val);
2375
2376 void __set_ctr_iv_prefix(const std::string& val);
2377
2378 bool operator == (const AesGcmCtrV1 & rhs) const
2379 {
2380 if (__isset.aad_metadata != rhs.__isset.aad_metadata)
2381 return false;
2382 else if (__isset.aad_metadata && !(aad_metadata == rhs.aad_metadata))
2383 return false;
2384 if (__isset.gcm_iv_prefix != rhs.__isset.gcm_iv_prefix)
2385 return false;
2386 else if (__isset.gcm_iv_prefix && !(gcm_iv_prefix == rhs.gcm_iv_prefix))
2387 return false;
2388 if (__isset.ctr_iv_prefix != rhs.__isset.ctr_iv_prefix)
2389 return false;
2390 else if (__isset.ctr_iv_prefix && !(ctr_iv_prefix == rhs.ctr_iv_prefix))
2391 return false;
2392 return true;
2393 }
2394 bool operator != (const AesGcmCtrV1 &rhs) const {
2395 return !(*this == rhs);
2396 }
2397
2398 bool operator < (const AesGcmCtrV1 & ) const;
2399
2400 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2401 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2402
2403 virtual void printTo(std::ostream& out) const;
2404};
2405
2406void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b);
2407
2408std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj);
2409
2410typedef struct _EncryptionAlgorithm__isset {
2411 _EncryptionAlgorithm__isset() : AES_GCM_V1(false), AES_GCM_CTR_V1(false) {}
2412 bool AES_GCM_V1 :1;
2413 bool AES_GCM_CTR_V1 :1;
2414} _EncryptionAlgorithm__isset;
2415
2416class EncryptionAlgorithm : public virtual ::apache::thrift::TBase {
2417 public:
2418
2419 EncryptionAlgorithm(const EncryptionAlgorithm&);
2420 EncryptionAlgorithm& operator=(const EncryptionAlgorithm&);
2421 EncryptionAlgorithm() {
2422 }
2423
2424 virtual ~EncryptionAlgorithm() throw();
2425 AesGcmV1 AES_GCM_V1;
2426 AesGcmCtrV1 AES_GCM_CTR_V1;
2427
2428 _EncryptionAlgorithm__isset __isset;
2429
2430 void __set_AES_GCM_V1(const AesGcmV1& val);
2431
2432 void __set_AES_GCM_CTR_V1(const AesGcmCtrV1& val);
2433
2434 bool operator == (const EncryptionAlgorithm & rhs) const
2435 {
2436 if (__isset.AES_GCM_V1 != rhs.__isset.AES_GCM_V1)
2437 return false;
2438 else if (__isset.AES_GCM_V1 && !(AES_GCM_V1 == rhs.AES_GCM_V1))
2439 return false;
2440 if (__isset.AES_GCM_CTR_V1 != rhs.__isset.AES_GCM_CTR_V1)
2441 return false;
2442 else if (__isset.AES_GCM_CTR_V1 && !(AES_GCM_CTR_V1 == rhs.AES_GCM_CTR_V1))
2443 return false;
2444 return true;
2445 }
2446 bool operator != (const EncryptionAlgorithm &rhs) const {
2447 return !(*this == rhs);
2448 }
2449
2450 bool operator < (const EncryptionAlgorithm & ) const;
2451
2452 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2453 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2454
2455 virtual void printTo(std::ostream& out) const;
2456};
2457
2458void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b);
2459
2460std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj);
2461
2462typedef struct _FileCryptoMetaData__isset {
2463 _FileCryptoMetaData__isset() : footer_key_metadata(false) {}
2464 bool footer_key_metadata :1;
2465} _FileCryptoMetaData__isset;
2466
2467class FileCryptoMetaData : public virtual ::apache::thrift::TBase {
2468 public:
2469
2470 FileCryptoMetaData(const FileCryptoMetaData&);
2471 FileCryptoMetaData& operator=(const FileCryptoMetaData&);
2472 FileCryptoMetaData() : encrypted_footer(0), footer_key_metadata(), footer_offset(0) {
2473 }
2474
2475 virtual ~FileCryptoMetaData() throw();
2476 EncryptionAlgorithm encryption_algorithm;
2477 bool encrypted_footer;
2478 std::string footer_key_metadata;
2479 int64_t footer_offset;
2480
2481 _FileCryptoMetaData__isset __isset;
2482
2483 void __set_encryption_algorithm(const EncryptionAlgorithm& val);
2484
2485 void __set_encrypted_footer(const bool val);
2486
2487 void __set_footer_key_metadata(const std::string& val);
2488
2489 void __set_footer_offset(const int64_t val);
2490
2491 bool operator == (const FileCryptoMetaData & rhs) const
2492 {
2493 if (!(encryption_algorithm == rhs.encryption_algorithm))
2494 return false;
2495 if (!(encrypted_footer == rhs.encrypted_footer))
2496 return false;
2497 if (__isset.footer_key_metadata != rhs.__isset.footer_key_metadata)
2498 return false;
2499 else if (__isset.footer_key_metadata && !(footer_key_metadata == rhs.footer_key_metadata))
2500 return false;
2501 if (!(footer_offset == rhs.footer_offset))
2502 return false;
2503 return true;
2504 }
2505 bool operator != (const FileCryptoMetaData &rhs) const {
2506 return !(*this == rhs);
2507 }
2508
2509 bool operator < (const FileCryptoMetaData & ) const;
2510
2511 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2512 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2513
2514 virtual void printTo(std::ostream& out) const;
2515};
2516
2517void swap(FileCryptoMetaData &a, FileCryptoMetaData &b);
2518
2519std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj);
2520
2521}} // namespace
2522
2523#endif
2524