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