parquet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From n...@apache.org
Subject [1/2] parquet-cpp git commit: PARQUET-449: updated to latest parquet.thrift
Date Mon, 25 Jan 2016 22:24:04 GMT
Repository: parquet-cpp
Updated Branches:
  refs/heads/master 0149a7afc -> 95277f3a4


http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/95277f3a/src/parquet/thrift/parquet_types.h
----------------------------------------------------------------------
diff --git a/src/parquet/thrift/parquet_types.h b/src/parquet/thrift/parquet_types.h
index 4360d02..5da94c8 100644
--- a/src/parquet/thrift/parquet_types.h
+++ b/src/parquet/thrift/parquet_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.3)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,11 +7,14 @@
 #ifndef parquet_TYPES_H
 #define parquet_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <thrift/cxxfunctional.h>
 
 
 namespace parquet {
@@ -38,7 +41,21 @@ struct ConvertedType {
     MAP_KEY_VALUE = 2,
     LIST = 3,
     ENUM = 4,
-    DECIMAL = 5
+    DECIMAL = 5,
+    DATE = 6,
+    TIME_MILLIS = 7,
+    TIMESTAMP_MILLIS = 9,
+    UINT_8 = 11,
+    UINT_16 = 12,
+    UINT_32 = 13,
+    UINT_64 = 14,
+    INT_8 = 15,
+    INT_16 = 16,
+    INT_32 = 17,
+    INT_64 = 18,
+    JSON = 19,
+    BSON = 20,
+    INTERVAL = 21
   };
 };
 
@@ -91,25 +108,51 @@ struct PageType {
 
 extern const std::map<int, const char*> _PageType_VALUES_TO_NAMES;
 
+class Statistics;
+
+class SchemaElement;
+
+class DataPageHeader;
+
+class IndexPageHeader;
+
+class DictionaryPageHeader;
+
+class DataPageHeaderV2;
+
+class PageHeader;
+
+class KeyValue;
+
+class SortingColumn;
+
+class PageEncodingStats;
+
+class ColumnMetaData;
+
+class ColumnChunk;
+
+class RowGroup;
+
+class FileMetaData;
+
 typedef struct _Statistics__isset {
   _Statistics__isset() : max(false), min(false), null_count(false), distinct_count(false)
{}
-  bool max;
-  bool min;
-  bool null_count;
-  bool distinct_count;
+  bool max :1;
+  bool min :1;
+  bool null_count :1;
+  bool distinct_count :1;
 } _Statistics__isset;
 
 class Statistics {
  public:
 
-  static const char* ascii_fingerprint; // = "CE004821871820DD79A8FD98BB101F6D";
-  static const uint8_t binary_fingerprint[16]; // = {0xCE,0x00,0x48,0x21,0x87,0x18,0x20,0xDD,0x79,0xA8,0xFD,0x98,0xBB,0x10,0x1F,0x6D};
-
+  Statistics(const Statistics&);
+  Statistics& operator=(const Statistics&);
   Statistics() : max(), min(), null_count(0), distinct_count(0) {
   }
 
-  virtual ~Statistics() throw() {}
-
+  virtual ~Statistics() throw();
   std::string max;
   std::string min;
   int64_t null_count;
@@ -117,25 +160,13 @@ class Statistics {
 
   _Statistics__isset __isset;
 
-  void __set_max(const std::string& val) {
-    max = val;
-    __isset.max = true;
-  }
+  void __set_max(const std::string& val);
 
-  void __set_min(const std::string& val) {
-    min = val;
-    __isset.min = true;
-  }
+  void __set_min(const std::string& val);
 
-  void __set_null_count(const int64_t val) {
-    null_count = val;
-    __isset.null_count = true;
-  }
+  void __set_null_count(const int64_t val);
 
-  void __set_distinct_count(const int64_t val) {
-    distinct_count = val;
-    __isset.distinct_count = true;
-  }
+  void __set_distinct_count(const int64_t val);
 
   bool operator == (const Statistics & rhs) const
   {
@@ -166,32 +197,38 @@ class Statistics {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(Statistics &a, Statistics &b);
 
+inline std::ostream& operator<<(std::ostream& out, const Statistics& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _SchemaElement__isset {
-  _SchemaElement__isset() : type(false), type_length(false), repetition_type(false), num_children(false),
converted_type(false), scale(false), precision(false) {}
-  bool type;
-  bool type_length;
-  bool repetition_type;
-  bool num_children;
-  bool converted_type;
-  bool scale;
-  bool precision;
+  _SchemaElement__isset() : type(false), type_length(false), repetition_type(false), num_children(false),
converted_type(false), scale(false), precision(false), field_id(false) {}
+  bool type :1;
+  bool type_length :1;
+  bool repetition_type :1;
+  bool num_children :1;
+  bool converted_type :1;
+  bool scale :1;
+  bool precision :1;
+  bool field_id :1;
 } _SchemaElement__isset;
 
 class SchemaElement {
  public:
 
-  static const char* ascii_fingerprint; // = "388A784401753800444CFEAC8BC1B1A1";
-  static const uint8_t binary_fingerprint[16]; // = {0x38,0x8A,0x78,0x44,0x01,0x75,0x38,0x00,0x44,0x4C,0xFE,0xAC,0x8B,0xC1,0xB1,0xA1};
-
-  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) {
+  SchemaElement(const SchemaElement&);
+  SchemaElement& operator=(const SchemaElement&);
+  SchemaElement() : type((Type::type)0), type_length(0), repetition_type((FieldRepetitionType::type)0),
name(), num_children(0), converted_type((ConvertedType::type)0), scale(0), precision(0), field_id(0)
{
   }
 
-  virtual ~SchemaElement() throw() {}
-
+  virtual ~SchemaElement() throw();
   Type::type type;
   int32_t type_length;
   FieldRepetitionType::type repetition_type;
@@ -200,47 +237,27 @@ class SchemaElement {
   ConvertedType::type converted_type;
   int32_t scale;
   int32_t precision;
+  int32_t field_id;
 
   _SchemaElement__isset __isset;
 
-  void __set_type(const Type::type val) {
-    type = val;
-    __isset.type = true;
-  }
+  void __set_type(const Type::type val);
 
-  void __set_type_length(const int32_t val) {
-    type_length = val;
-    __isset.type_length = true;
-  }
+  void __set_type_length(const int32_t val);
 
-  void __set_repetition_type(const FieldRepetitionType::type val) {
-    repetition_type = val;
-    __isset.repetition_type = true;
-  }
+  void __set_repetition_type(const FieldRepetitionType::type val);
 
-  void __set_name(const std::string& val) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_num_children(const int32_t val) {
-    num_children = val;
-    __isset.num_children = true;
-  }
+  void __set_num_children(const int32_t val);
 
-  void __set_converted_type(const ConvertedType::type val) {
-    converted_type = val;
-    __isset.converted_type = true;
-  }
+  void __set_converted_type(const ConvertedType::type val);
 
-  void __set_scale(const int32_t val) {
-    scale = val;
-    __isset.scale = true;
-  }
+  void __set_scale(const int32_t val);
 
-  void __set_precision(const int32_t val) {
-    precision = val;
-    __isset.precision = true;
-  }
+  void __set_precision(const int32_t val);
+
+  void __set_field_id(const int32_t val);
 
   bool operator == (const SchemaElement & rhs) const
   {
@@ -274,6 +291,10 @@ class SchemaElement {
       return false;
     else if (__isset.precision && !(precision == rhs.precision))
       return false;
+    if (__isset.field_id != rhs.__isset.field_id)
+      return false;
+    else if (__isset.field_id && !(field_id == rhs.field_id))
+      return false;
     return true;
   }
   bool operator != (const SchemaElement &rhs) const {
@@ -285,26 +306,31 @@ class SchemaElement {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(SchemaElement &a, SchemaElement &b);
 
+inline std::ostream& operator<<(std::ostream& out, const SchemaElement&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _DataPageHeader__isset {
   _DataPageHeader__isset() : statistics(false) {}
-  bool statistics;
+  bool statistics :1;
 } _DataPageHeader__isset;
 
 class DataPageHeader {
  public:
 
-  static const char* ascii_fingerprint; // = "5FC1792B0483E9C984475384165040B1";
-  static const uint8_t binary_fingerprint[16]; // = {0x5F,0xC1,0x79,0x2B,0x04,0x83,0xE9,0xC9,0x84,0x47,0x53,0x84,0x16,0x50,0x40,0xB1};
-
+  DataPageHeader(const DataPageHeader&);
+  DataPageHeader& operator=(const DataPageHeader&);
   DataPageHeader() : num_values(0), encoding((Encoding::type)0), definition_level_encoding((Encoding::type)0),
repetition_level_encoding((Encoding::type)0) {
   }
 
-  virtual ~DataPageHeader() throw() {}
-
+  virtual ~DataPageHeader() throw();
   int32_t num_values;
   Encoding::type encoding;
   Encoding::type definition_level_encoding;
@@ -313,26 +339,15 @@ class DataPageHeader {
 
   _DataPageHeader__isset __isset;
 
-  void __set_num_values(const int32_t val) {
-    num_values = val;
-  }
+  void __set_num_values(const int32_t val);
 
-  void __set_encoding(const Encoding::type val) {
-    encoding = val;
-  }
+  void __set_encoding(const Encoding::type val);
 
-  void __set_definition_level_encoding(const Encoding::type val) {
-    definition_level_encoding = val;
-  }
+  void __set_definition_level_encoding(const Encoding::type val);
 
-  void __set_repetition_level_encoding(const Encoding::type val) {
-    repetition_level_encoding = val;
-  }
+  void __set_repetition_level_encoding(const Encoding::type val);
 
-  void __set_statistics(const Statistics& val) {
-    statistics = val;
-    __isset.statistics = true;
-  }
+  void __set_statistics(const Statistics& val);
 
   bool operator == (const DataPageHeader & rhs) const
   {
@@ -359,22 +374,27 @@ class DataPageHeader {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(DataPageHeader &a, DataPageHeader &b);
 
+inline std::ostream& operator<<(std::ostream& out, const DataPageHeader&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 
 class IndexPageHeader {
  public:
 
-  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
-  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
-
+  IndexPageHeader(const IndexPageHeader&);
+  IndexPageHeader& operator=(const IndexPageHeader&);
   IndexPageHeader() {
   }
 
-  virtual ~IndexPageHeader() throw() {}
-
+  virtual ~IndexPageHeader() throw();
 
   bool operator == (const IndexPageHeader & /* rhs */) const
   {
@@ -389,44 +409,42 @@ class IndexPageHeader {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(IndexPageHeader &a, IndexPageHeader &b);
 
+inline std::ostream& operator<<(std::ostream& out, const IndexPageHeader&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _DictionaryPageHeader__isset {
   _DictionaryPageHeader__isset() : is_sorted(false) {}
-  bool is_sorted;
+  bool is_sorted :1;
 } _DictionaryPageHeader__isset;
 
 class DictionaryPageHeader {
  public:
 
-  static const char* ascii_fingerprint; // = "B149E4528254D495610C22AE4BD539C5";
-  static const uint8_t binary_fingerprint[16]; // = {0xB1,0x49,0xE4,0x52,0x82,0x54,0xD4,0x95,0x61,0x0C,0x22,0xAE,0x4B,0xD5,0x39,0xC5};
-
+  DictionaryPageHeader(const DictionaryPageHeader&);
+  DictionaryPageHeader& operator=(const DictionaryPageHeader&);
   DictionaryPageHeader() : num_values(0), encoding((Encoding::type)0), is_sorted(0) {
   }
 
-  virtual ~DictionaryPageHeader() throw() {}
-
+  virtual ~DictionaryPageHeader() throw();
   int32_t num_values;
   Encoding::type encoding;
   bool is_sorted;
 
   _DictionaryPageHeader__isset __isset;
 
-  void __set_num_values(const int32_t val) {
-    num_values = val;
-  }
+  void __set_num_values(const int32_t val);
 
-  void __set_encoding(const Encoding::type val) {
-    encoding = val;
-  }
+  void __set_encoding(const Encoding::type val);
 
-  void __set_is_sorted(const bool val) {
-    is_sorted = val;
-    __isset.is_sorted = true;
-  }
+  void __set_is_sorted(const bool val);
 
   bool operator == (const DictionaryPageHeader & rhs) const
   {
@@ -449,27 +467,32 @@ class DictionaryPageHeader {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(DictionaryPageHeader &a, DictionaryPageHeader &b);
 
+inline std::ostream& operator<<(std::ostream& out, const DictionaryPageHeader&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _DataPageHeaderV2__isset {
   _DataPageHeaderV2__isset() : is_compressed(true), statistics(false) {}
-  bool is_compressed;
-  bool statistics;
+  bool is_compressed :1;
+  bool statistics :1;
 } _DataPageHeaderV2__isset;
 
 class DataPageHeaderV2 {
  public:
 
-  static const char* ascii_fingerprint; // = "69FF2F6BD1A443440D5E46ABA5A3A919";
-  static const uint8_t binary_fingerprint[16]; // = {0x69,0xFF,0x2F,0x6B,0xD1,0xA4,0x43,0x44,0x0D,0x5E,0x46,0xAB,0xA5,0xA3,0xA9,0x19};
-
+  DataPageHeaderV2(const DataPageHeaderV2&);
+  DataPageHeaderV2& operator=(const DataPageHeaderV2&);
   DataPageHeaderV2() : num_values(0), num_nulls(0), num_rows(0), encoding((Encoding::type)0),
definition_levels_byte_length(0), repetition_levels_byte_length(0), is_compressed(true) {
   }
 
-  virtual ~DataPageHeaderV2() throw() {}
-
+  virtual ~DataPageHeaderV2() throw();
   int32_t num_values;
   int32_t num_nulls;
   int32_t num_rows;
@@ -481,39 +504,21 @@ class DataPageHeaderV2 {
 
   _DataPageHeaderV2__isset __isset;
 
-  void __set_num_values(const int32_t val) {
-    num_values = val;
-  }
+  void __set_num_values(const int32_t val);
 
-  void __set_num_nulls(const int32_t val) {
-    num_nulls = val;
-  }
+  void __set_num_nulls(const int32_t val);
 
-  void __set_num_rows(const int32_t val) {
-    num_rows = val;
-  }
+  void __set_num_rows(const int32_t val);
 
-  void __set_encoding(const Encoding::type val) {
-    encoding = val;
-  }
+  void __set_encoding(const Encoding::type val);
 
-  void __set_definition_levels_byte_length(const int32_t val) {
-    definition_levels_byte_length = val;
-  }
+  void __set_definition_levels_byte_length(const int32_t val);
 
-  void __set_repetition_levels_byte_length(const int32_t val) {
-    repetition_levels_byte_length = val;
-  }
+  void __set_repetition_levels_byte_length(const int32_t val);
 
-  void __set_is_compressed(const bool val) {
-    is_compressed = val;
-    __isset.is_compressed = true;
-  }
+  void __set_is_compressed(const bool val);
 
-  void __set_statistics(const Statistics& val) {
-    statistics = val;
-    __isset.statistics = true;
-  }
+  void __set_statistics(const Statistics& val);
 
   bool operator == (const DataPageHeaderV2 & rhs) const
   {
@@ -548,30 +553,35 @@ class DataPageHeaderV2 {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b);
 
+inline std::ostream& operator<<(std::ostream& out, const DataPageHeaderV2&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _PageHeader__isset {
   _PageHeader__isset() : crc(false), data_page_header(false), index_page_header(false), dictionary_page_header(false),
data_page_header_v2(false) {}
-  bool crc;
-  bool data_page_header;
-  bool index_page_header;
-  bool dictionary_page_header;
-  bool data_page_header_v2;
+  bool crc :1;
+  bool data_page_header :1;
+  bool index_page_header :1;
+  bool dictionary_page_header :1;
+  bool data_page_header_v2 :1;
 } _PageHeader__isset;
 
 class PageHeader {
  public:
 
-  static const char* ascii_fingerprint; // = "B5BD2BDF3756C883A58B30B9C9F204A0";
-  static const uint8_t binary_fingerprint[16]; // = {0xB5,0xBD,0x2B,0xDF,0x37,0x56,0xC8,0x83,0xA5,0x8B,0x30,0xB9,0xC9,0xF2,0x04,0xA0};
-
+  PageHeader(const PageHeader&);
+  PageHeader& operator=(const PageHeader&);
   PageHeader() : type((PageType::type)0), uncompressed_page_size(0), compressed_page_size(0),
crc(0) {
   }
 
-  virtual ~PageHeader() throw() {}
-
+  virtual ~PageHeader() throw();
   PageType::type type;
   int32_t uncompressed_page_size;
   int32_t compressed_page_size;
@@ -583,42 +593,21 @@ class PageHeader {
 
   _PageHeader__isset __isset;
 
-  void __set_type(const PageType::type val) {
-    type = val;
-  }
+  void __set_type(const PageType::type val);
 
-  void __set_uncompressed_page_size(const int32_t val) {
-    uncompressed_page_size = val;
-  }
+  void __set_uncompressed_page_size(const int32_t val);
 
-  void __set_compressed_page_size(const int32_t val) {
-    compressed_page_size = val;
-  }
+  void __set_compressed_page_size(const int32_t val);
 
-  void __set_crc(const int32_t val) {
-    crc = val;
-    __isset.crc = true;
-  }
+  void __set_crc(const int32_t val);
 
-  void __set_data_page_header(const DataPageHeader& val) {
-    data_page_header = val;
-    __isset.data_page_header = true;
-  }
+  void __set_data_page_header(const DataPageHeader& val);
 
-  void __set_index_page_header(const IndexPageHeader& val) {
-    index_page_header = val;
-    __isset.index_page_header = true;
-  }
+  void __set_index_page_header(const IndexPageHeader& val);
 
-  void __set_dictionary_page_header(const DictionaryPageHeader& val) {
-    dictionary_page_header = val;
-    __isset.dictionary_page_header = true;
-  }
+  void __set_dictionary_page_header(const DictionaryPageHeader& val);
 
-  void __set_data_page_header_v2(const DataPageHeaderV2& val) {
-    data_page_header_v2 = val;
-    __isset.data_page_header_v2 = true;
-  }
+  void __set_data_page_header_v2(const DataPageHeaderV2& val);
 
   bool operator == (const PageHeader & rhs) const
   {
@@ -659,39 +648,39 @@ class PageHeader {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(PageHeader &a, PageHeader &b);
 
+inline std::ostream& operator<<(std::ostream& out, const PageHeader& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _KeyValue__isset {
   _KeyValue__isset() : value(false) {}
-  bool value;
+  bool value :1;
 } _KeyValue__isset;
 
 class KeyValue {
  public:
 
-  static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9";
-  static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
-
+  KeyValue(const KeyValue&);
+  KeyValue& operator=(const KeyValue&);
   KeyValue() : key(), value() {
   }
 
-  virtual ~KeyValue() throw() {}
-
+  virtual ~KeyValue() throw();
   std::string key;
   std::string value;
 
   _KeyValue__isset __isset;
 
-  void __set_key(const std::string& val) {
-    key = val;
-  }
+  void __set_key(const std::string& val);
 
-  void __set_value(const std::string& val) {
-    value = val;
-    __isset.value = true;
-  }
+  void __set_value(const std::string& val);
 
   bool operator == (const KeyValue & rhs) const
   {
@@ -712,37 +701,36 @@ class KeyValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(KeyValue &a, KeyValue &b);
 
+inline std::ostream& operator<<(std::ostream& out, const KeyValue& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 
 class SortingColumn {
  public:
 
-  static const char* ascii_fingerprint; // = "F079C2D58A783AD90F9BE05D10DBBC6F";
-  static const uint8_t binary_fingerprint[16]; // = {0xF0,0x79,0xC2,0xD5,0x8A,0x78,0x3A,0xD9,0x0F,0x9B,0xE0,0x5D,0x10,0xDB,0xBC,0x6F};
-
+  SortingColumn(const SortingColumn&);
+  SortingColumn& operator=(const SortingColumn&);
   SortingColumn() : column_idx(0), descending(0), nulls_first(0) {
   }
 
-  virtual ~SortingColumn() throw() {}
-
+  virtual ~SortingColumn() throw();
   int32_t column_idx;
   bool descending;
   bool nulls_first;
 
-  void __set_column_idx(const int32_t val) {
-    column_idx = val;
-  }
+  void __set_column_idx(const int32_t val);
 
-  void __set_descending(const bool val) {
-    descending = val;
-  }
+  void __set_descending(const bool val);
 
-  void __set_nulls_first(const bool val) {
-    nulls_first = val;
-  }
+  void __set_nulls_first(const bool val);
 
   bool operator == (const SortingColumn & rhs) const
   {
@@ -763,29 +751,85 @@ class SortingColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(SortingColumn &a, SortingColumn &b);
 
+inline std::ostream& operator<<(std::ostream& out, const SortingColumn&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+class PageEncodingStats {
+ public:
+
+  PageEncodingStats(const PageEncodingStats&);
+  PageEncodingStats& operator=(const PageEncodingStats&);
+  PageEncodingStats() : page_type((PageType::type)0), encoding((Encoding::type)0), count(0)
{
+  }
+
+  virtual ~PageEncodingStats() throw();
+  PageType::type page_type;
+  Encoding::type encoding;
+  int32_t count;
+
+  void __set_page_type(const PageType::type val);
+
+  void __set_encoding(const Encoding::type val);
+
+  void __set_count(const int32_t val);
+
+  bool operator == (const PageEncodingStats & rhs) const
+  {
+    if (!(page_type == rhs.page_type))
+      return false;
+    if (!(encoding == rhs.encoding))
+      return false;
+    if (!(count == rhs.count))
+      return false;
+    return true;
+  }
+  bool operator != (const PageEncodingStats &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const PageEncodingStats & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(PageEncodingStats &a, PageEncodingStats &b);
+
+inline std::ostream& operator<<(std::ostream& out, const PageEncodingStats&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ColumnMetaData__isset {
-  _ColumnMetaData__isset() : key_value_metadata(false), index_page_offset(false), dictionary_page_offset(false),
statistics(false) {}
-  bool key_value_metadata;
-  bool index_page_offset;
-  bool dictionary_page_offset;
-  bool statistics;
+  _ColumnMetaData__isset() : key_value_metadata(false), index_page_offset(false), dictionary_page_offset(false),
statistics(false), encoding_stats(false) {}
+  bool key_value_metadata :1;
+  bool index_page_offset :1;
+  bool dictionary_page_offset :1;
+  bool statistics :1;
+  bool encoding_stats :1;
 } _ColumnMetaData__isset;
 
 class ColumnMetaData {
  public:
 
-  static const char* ascii_fingerprint; // = "1AF797732BCB4465C6314FB29B86638D";
-  static const uint8_t binary_fingerprint[16]; // = {0x1A,0xF7,0x97,0x73,0x2B,0xCB,0x44,0x65,0xC6,0x31,0x4F,0xB2,0x9B,0x86,0x63,0x8D};
-
+  ColumnMetaData(const ColumnMetaData&);
+  ColumnMetaData& operator=(const ColumnMetaData&);
   ColumnMetaData() : type((Type::type)0), codec((CompressionCodec::type)0), num_values(0),
total_uncompressed_size(0), total_compressed_size(0), data_page_offset(0), index_page_offset(0),
dictionary_page_offset(0) {
   }
 
-  virtual ~ColumnMetaData() throw() {}
-
+  virtual ~ColumnMetaData() throw();
   Type::type type;
   std::vector<Encoding::type>  encodings;
   std::vector<std::string>  path_in_schema;
@@ -798,60 +842,35 @@ class ColumnMetaData {
   int64_t index_page_offset;
   int64_t dictionary_page_offset;
   Statistics statistics;
+  std::vector<PageEncodingStats>  encoding_stats;
 
   _ColumnMetaData__isset __isset;
 
-  void __set_type(const Type::type val) {
-    type = val;
-  }
+  void __set_type(const Type::type val);
 
-  void __set_encodings(const std::vector<Encoding::type> & val) {
-    encodings = val;
-  }
+  void __set_encodings(const std::vector<Encoding::type> & val);
 
-  void __set_path_in_schema(const std::vector<std::string> & val) {
-    path_in_schema = val;
-  }
+  void __set_path_in_schema(const std::vector<std::string> & val);
 
-  void __set_codec(const CompressionCodec::type val) {
-    codec = val;
-  }
+  void __set_codec(const CompressionCodec::type val);
 
-  void __set_num_values(const int64_t val) {
-    num_values = val;
-  }
+  void __set_num_values(const int64_t val);
 
-  void __set_total_uncompressed_size(const int64_t val) {
-    total_uncompressed_size = val;
-  }
+  void __set_total_uncompressed_size(const int64_t val);
 
-  void __set_total_compressed_size(const int64_t val) {
-    total_compressed_size = val;
-  }
+  void __set_total_compressed_size(const int64_t val);
 
-  void __set_key_value_metadata(const std::vector<KeyValue> & val) {
-    key_value_metadata = val;
-    __isset.key_value_metadata = true;
-  }
+  void __set_key_value_metadata(const std::vector<KeyValue> & val);
 
-  void __set_data_page_offset(const int64_t val) {
-    data_page_offset = val;
-  }
+  void __set_data_page_offset(const int64_t val);
 
-  void __set_index_page_offset(const int64_t val) {
-    index_page_offset = val;
-    __isset.index_page_offset = true;
-  }
+  void __set_index_page_offset(const int64_t val);
 
-  void __set_dictionary_page_offset(const int64_t val) {
-    dictionary_page_offset = val;
-    __isset.dictionary_page_offset = true;
-  }
+  void __set_dictionary_page_offset(const int64_t val);
 
-  void __set_statistics(const Statistics& val) {
-    statistics = val;
-    __isset.statistics = true;
-  }
+  void __set_statistics(const Statistics& val);
+
+  void __set_encoding_stats(const std::vector<PageEncodingStats> & val);
 
   bool operator == (const ColumnMetaData & rhs) const
   {
@@ -887,6 +906,10 @@ class ColumnMetaData {
       return false;
     else if (__isset.statistics && !(statistics == rhs.statistics))
       return false;
+    if (__isset.encoding_stats != rhs.__isset.encoding_stats)
+      return false;
+    else if (__isset.encoding_stats && !(encoding_stats == rhs.encoding_stats))
+      return false;
     return true;
   }
   bool operator != (const ColumnMetaData &rhs) const {
@@ -898,46 +921,43 @@ class ColumnMetaData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ColumnMetaData &a, ColumnMetaData &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ColumnMetaData&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ColumnChunk__isset {
   _ColumnChunk__isset() : file_path(false), meta_data(false) {}
-  bool file_path;
-  bool meta_data;
+  bool file_path :1;
+  bool meta_data :1;
 } _ColumnChunk__isset;
 
 class ColumnChunk {
  public:
 
-  static const char* ascii_fingerprint; // = "169FC47057EF3D82E2FACDDEC2641AE8";
-  static const uint8_t binary_fingerprint[16]; // = {0x16,0x9F,0xC4,0x70,0x57,0xEF,0x3D,0x82,0xE2,0xFA,0xCD,0xDE,0xC2,0x64,0x1A,0xE8};
-
+  ColumnChunk(const ColumnChunk&);
+  ColumnChunk& operator=(const ColumnChunk&);
   ColumnChunk() : file_path(), file_offset(0) {
   }
 
-  virtual ~ColumnChunk() throw() {}
-
+  virtual ~ColumnChunk() throw();
   std::string file_path;
   int64_t file_offset;
   ColumnMetaData meta_data;
 
   _ColumnChunk__isset __isset;
 
-  void __set_file_path(const std::string& val) {
-    file_path = val;
-    __isset.file_path = true;
-  }
+  void __set_file_path(const std::string& val);
 
-  void __set_file_offset(const int64_t val) {
-    file_offset = val;
-  }
+  void __set_file_offset(const int64_t val);
 
-  void __set_meta_data(const ColumnMetaData& val) {
-    meta_data = val;
-    __isset.meta_data = true;
-  }
+  void __set_meta_data(const ColumnMetaData& val);
 
   bool operator == (const ColumnChunk & rhs) const
   {
@@ -962,26 +982,31 @@ class ColumnChunk {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ColumnChunk &a, ColumnChunk &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _RowGroup__isset {
   _RowGroup__isset() : sorting_columns(false) {}
-  bool sorting_columns;
+  bool sorting_columns :1;
 } _RowGroup__isset;
 
 class RowGroup {
  public:
 
-  static const char* ascii_fingerprint; // = "DC7968627FA826DDC4C6C9BE773586C9";
-  static const uint8_t binary_fingerprint[16]; // = {0xDC,0x79,0x68,0x62,0x7F,0xA8,0x26,0xDD,0xC4,0xC6,0xC9,0xBE,0x77,0x35,0x86,0xC9};
-
+  RowGroup(const RowGroup&);
+  RowGroup& operator=(const RowGroup&);
   RowGroup() : total_byte_size(0), num_rows(0) {
   }
 
-  virtual ~RowGroup() throw() {}
-
+  virtual ~RowGroup() throw();
   std::vector<ColumnChunk>  columns;
   int64_t total_byte_size;
   int64_t num_rows;
@@ -989,22 +1014,13 @@ class RowGroup {
 
   _RowGroup__isset __isset;
 
-  void __set_columns(const std::vector<ColumnChunk> & val) {
-    columns = val;
-  }
+  void __set_columns(const std::vector<ColumnChunk> & val);
 
-  void __set_total_byte_size(const int64_t val) {
-    total_byte_size = val;
-  }
+  void __set_total_byte_size(const int64_t val);
 
-  void __set_num_rows(const int64_t val) {
-    num_rows = val;
-  }
+  void __set_num_rows(const int64_t val);
 
-  void __set_sorting_columns(const std::vector<SortingColumn> & val) {
-    sorting_columns = val;
-    __isset.sorting_columns = true;
-  }
+  void __set_sorting_columns(const std::vector<SortingColumn> & val);
 
   bool operator == (const RowGroup & rhs) const
   {
@@ -1029,27 +1045,32 @@ class RowGroup {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(RowGroup &a, RowGroup &b);
 
+inline std::ostream& operator<<(std::ostream& out, const RowGroup& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _FileMetaData__isset {
   _FileMetaData__isset() : key_value_metadata(false), created_by(false) {}
-  bool key_value_metadata;
-  bool created_by;
+  bool key_value_metadata :1;
+  bool created_by :1;
 } _FileMetaData__isset;
 
 class FileMetaData {
  public:
 
-  static const char* ascii_fingerprint; // = "44DC7D83A66D54A7B7892A985C4125C9";
-  static const uint8_t binary_fingerprint[16]; // = {0x44,0xDC,0x7D,0x83,0xA6,0x6D,0x54,0xA7,0xB7,0x89,0x2A,0x98,0x5C,0x41,0x25,0xC9};
-
+  FileMetaData(const FileMetaData&);
+  FileMetaData& operator=(const FileMetaData&);
   FileMetaData() : version(0), num_rows(0), created_by() {
   }
 
-  virtual ~FileMetaData() throw() {}
-
+  virtual ~FileMetaData() throw();
   int32_t version;
   std::vector<SchemaElement>  schema;
   int64_t num_rows;
@@ -1059,31 +1080,17 @@ class FileMetaData {
 
   _FileMetaData__isset __isset;
 
-  void __set_version(const int32_t val) {
-    version = val;
-  }
+  void __set_version(const int32_t val);
 
-  void __set_schema(const std::vector<SchemaElement> & val) {
-    schema = val;
-  }
+  void __set_schema(const std::vector<SchemaElement> & val);
 
-  void __set_num_rows(const int64_t val) {
-    num_rows = val;
-  }
+  void __set_num_rows(const int64_t val);
 
-  void __set_row_groups(const std::vector<RowGroup> & val) {
-    row_groups = val;
-  }
+  void __set_row_groups(const std::vector<RowGroup> & val);
 
-  void __set_key_value_metadata(const std::vector<KeyValue> & val) {
-    key_value_metadata = val;
-    __isset.key_value_metadata = true;
-  }
+  void __set_key_value_metadata(const std::vector<KeyValue> & val);
 
-  void __set_created_by(const std::string& val) {
-    created_by = val;
-    __isset.created_by = true;
-  }
+  void __set_created_by(const std::string& val);
 
   bool operator == (const FileMetaData & rhs) const
   {
@@ -1114,10 +1121,17 @@ class FileMetaData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(FileMetaData &a, FileMetaData &b);
 
+inline std::ostream& operator<<(std::ostream& out, const FileMetaData&
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 } // namespace
 
 #endif

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/95277f3a/thirdparty/build_thirdparty.sh
----------------------------------------------------------------------
diff --git a/thirdparty/build_thirdparty.sh b/thirdparty/build_thirdparty.sh
index 891e613..dc0bedb 100755
--- a/thirdparty/build_thirdparty.sh
+++ b/thirdparty/build_thirdparty.sh
@@ -76,11 +76,9 @@ if [ -n "$F_ALL" -o -n "$F_THRIFT" ]; then
     # such a way that ./configure can find them
     cd $TP_DIR/$THRIFT_BASEDIR
     ./configure CXXFLAGS='-fPIC' --without-qt4 --without-c_glib --without-csharp --without-java
--without-erlang --without-nodejs --without-lua --without-python --without-perl --without-php
--without-php_extension --without-ruby --without-haskell --without-go --without-d --with-cpp
--prefix=$PREFIX
-    make clean
     make install
   fi
 fi
 
 echo "---------------------"
 echo "Thirdparty dependencies built and installed into $PREFIX successfully"
-

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/95277f3a/thirdparty/versions.sh
----------------------------------------------------------------------
diff --git a/thirdparty/versions.sh b/thirdparty/versions.sh
index 72f1156..c7cbeed 100644
--- a/thirdparty/versions.sh
+++ b/thirdparty/versions.sh
@@ -6,6 +6,6 @@ SNAPPY_VERSION=1.1.3
 SNAPPY_URL="https://github.com/google/snappy/releases/download/${SNAPPY_VERSION}/snappy-${SNAPPY_VERSION}.tar.gz"
 SNAPPY_BASEDIR=snappy-$SNAPPY_VERSION
 
-THRIFT_VERSION=0.9.1
+THRIFT_VERSION=0.9.3
 THRIFT_URL="http://archive.apache.org/dist/thrift/${THRIFT_VERSION}/thrift-${THRIFT_VERSION}.tar.gz"
 THRIFT_BASEDIR=thrift-$THRIFT_VERSION


Mime
View raw message