hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject svn commit: r1582546 [1/2] - in /hive/trunk: data/files/ metastore/if/ metastore/src/gen/thrift/gen-cpp/ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ metastore/src/gen/thrift/gen-php/metastore/ metastore/src/gen/thrift/ge...
Date Thu, 27 Mar 2014 23:40:04 GMT
Author: sershe
Date: Thu Mar 27 23:40:03 2014
New Revision: 1582546

URL: http://svn.apache.org/r1582546
Log:
HIVE-6701 Analyze table compute statistics for decimal columns. (Sergey Shelukhin and Jitendra Nath Pandey, reviewed by Ashutosh Chauhan)

Added:
    hive/trunk/data/files/decimal.txt
    hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Decimal.java
    hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DecimalColumnStatsData.java
    hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/DecimalNumDistinctValueEstimator.java
    hive/trunk/ql/src/test/queries/clientpositive/compute_stats_decimal.q
    hive/trunk/ql/src/test/results/clientpositive/compute_stats_decimal.q.out
Modified:
    hive/trunk/metastore/if/hive_metastore.thrift
    hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
    hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
    hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ColumnStatisticsData.java
    hive/trunk/metastore/src/gen/thrift/gen-php/metastore/Types.php
    hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
    hive/trunk/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
    hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java
    hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/StatObjectConverter.java
    hive/trunk/metastore/src/model/org/apache/hadoop/hive/metastore/model/MPartitionColumnStatistics.java
    hive/trunk/metastore/src/model/org/apache/hadoop/hive/metastore/model/MTableColumnStatistics.java
    hive/trunk/metastore/src/model/package.jdo
    hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnStatsTask.java
    hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFComputeStats.java

Added: hive/trunk/data/files/decimal.txt
URL: http://svn.apache.org/viewvc/hive/trunk/data/files/decimal.txt?rev=1582546&view=auto
==============================================================================
--- hive/trunk/data/files/decimal.txt (added)
+++ hive/trunk/data/files/decimal.txt Thu Mar 27 23:40:03 2014
@@ -0,0 +1,18 @@
+55.33
+44.2
+435.33
+324.33
+324.33
+44.2
+55.3
+55.3
+0.0
+
+66.4
+23.22
+-87.2
+
+33.44
+55.3
+435.331
+-0.342
\ No newline at end of file

Modified: hive/trunk/metastore/if/hive_metastore.thrift
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/if/hive_metastore.thrift?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/if/hive_metastore.thrift (original)
+++ hive/trunk/metastore/if/hive_metastore.thrift Thu Mar 27 23:40:03 2014
@@ -291,12 +291,26 @@ struct BinaryColumnStatsData {
 3: required i64 numNulls
 }
 
+
+struct Decimal {
+1: required binary unscaled,
+3: required i16 scale
+}
+
+struct DecimalColumnStatsData {
+1: required Decimal lowValue,
+2: required Decimal highValue,
+3: required i64 numNulls,
+4: required i64 numDVs
+}
+
 union ColumnStatisticsData {
 1: BooleanColumnStatsData booleanStats,
 2: LongColumnStatsData longStats,
 3: DoubleColumnStatsData doubleStats,
 4: StringColumnStatsData stringStats,
-5: BinaryColumnStatsData binaryStats
+5: BinaryColumnStatsData binaryStats,
+6: DecimalColumnStatsData decimalStats
 }
 
 struct ColumnStatisticsObj {

Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Thu Mar 27 23:40:03 2014
@@ -3547,8 +3547,200 @@ void swap(BinaryColumnStatsData &a, Bina
   swap(a.numNulls, b.numNulls);
 }
 
-const char* ColumnStatisticsData::ascii_fingerprint = "3D106F26C0761EF37E58CAFAA3F1651C";
-const uint8_t ColumnStatisticsData::binary_fingerprint[16] = {0x3D,0x10,0x6F,0x26,0xC0,0x76,0x1E,0xF3,0x7E,0x58,0xCA,0xFA,0xA3,0xF1,0x65,0x1C};
+const char* Decimal::ascii_fingerprint = "C4DDF6759F9B17C5C380806CE743DE8E";
+const uint8_t Decimal::binary_fingerprint[16] = {0xC4,0xDD,0xF6,0x75,0x9F,0x9B,0x17,0xC5,0xC3,0x80,0x80,0x6C,0xE7,0x43,0xDE,0x8E};
+
+uint32_t Decimal::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_unscaled = false;
+  bool isset_scale = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->unscaled);
+          isset_unscaled = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->scale);
+          isset_scale = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_unscaled)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_scale)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Decimal::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Decimal");
+
+  xfer += oprot->writeFieldBegin("unscaled", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->unscaled);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("scale", ::apache::thrift::protocol::T_I16, 3);
+  xfer += oprot->writeI16(this->scale);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Decimal &a, Decimal &b) {
+  using ::std::swap;
+  swap(a.unscaled, b.unscaled);
+  swap(a.scale, b.scale);
+}
+
+const char* DecimalColumnStatsData::ascii_fingerprint = "3AE5C36598A014EE815B87600C3087B5";
+const uint8_t DecimalColumnStatsData::binary_fingerprint[16] = {0x3A,0xE5,0xC3,0x65,0x98,0xA0,0x14,0xEE,0x81,0x5B,0x87,0x60,0x0C,0x30,0x87,0xB5};
+
+uint32_t DecimalColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_lowValue = false;
+  bool isset_highValue = false;
+  bool isset_numNulls = false;
+  bool isset_numDVs = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->lowValue.read(iprot);
+          isset_lowValue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->highValue.read(iprot);
+          isset_highValue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->numNulls);
+          isset_numNulls = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->numDVs);
+          isset_numDVs = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_lowValue)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_highValue)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_numNulls)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_numDVs)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t DecimalColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("DecimalColumnStatsData");
+
+  xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->lowValue.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->highValue.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64(this->numNulls);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4);
+  xfer += oprot->writeI64(this->numDVs);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) {
+  using ::std::swap;
+  swap(a.lowValue, b.lowValue);
+  swap(a.highValue, b.highValue);
+  swap(a.numNulls, b.numNulls);
+  swap(a.numDVs, b.numDVs);
+}
+
+const char* ColumnStatisticsData::ascii_fingerprint = "343F5865568AF7DA61829A616EB8C57C";
+const uint8_t ColumnStatisticsData::binary_fingerprint[16] = {0x34,0x3F,0x58,0x65,0x56,0x8A,0xF7,0xDA,0x61,0x82,0x9A,0x61,0x6E,0xB8,0xC5,0x7C};
 
 uint32_t ColumnStatisticsData::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -3610,6 +3802,14 @@ uint32_t ColumnStatisticsData::read(::ap
           xfer += iprot->skip(ftype);
         }
         break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->decimalStats.read(iprot);
+          this->__isset.decimalStats = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -3646,6 +3846,10 @@ uint32_t ColumnStatisticsData::write(::a
   xfer += this->binaryStats.write(oprot);
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("decimalStats", ::apache::thrift::protocol::T_STRUCT, 6);
+  xfer += this->decimalStats.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -3658,11 +3862,12 @@ void swap(ColumnStatisticsData &a, Colum
   swap(a.doubleStats, b.doubleStats);
   swap(a.stringStats, b.stringStats);
   swap(a.binaryStats, b.binaryStats);
+  swap(a.decimalStats, b.decimalStats);
   swap(a.__isset, b.__isset);
 }
 
-const char* ColumnStatisticsObj::ascii_fingerprint = "DEE09584C51BCAF60824FE4509B59567";
-const uint8_t ColumnStatisticsObj::binary_fingerprint[16] = {0xDE,0xE0,0x95,0x84,0xC5,0x1B,0xCA,0xF6,0x08,0x24,0xFE,0x45,0x09,0xB5,0x95,0x67};
+const char* ColumnStatisticsObj::ascii_fingerprint = "CFDBB9DFF4F1670367EA5356861EC180";
+const uint8_t ColumnStatisticsObj::binary_fingerprint[16] = {0xCF,0xDB,0xB9,0xDF,0xF4,0xF1,0x67,0x03,0x67,0xEA,0x53,0x56,0x86,0x1E,0xC1,0x80};
 
 uint32_t ColumnStatisticsObj::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -3882,8 +4087,8 @@ void swap(ColumnStatisticsDesc &a, Colum
   swap(a.__isset, b.__isset);
 }
 
-const char* ColumnStatistics::ascii_fingerprint = "681BDBD0CBB53373AC1C9C0C2E26BEAB";
-const uint8_t ColumnStatistics::binary_fingerprint[16] = {0x68,0x1B,0xDB,0xD0,0xCB,0xB5,0x33,0x73,0xAC,0x1C,0x9C,0x0C,0x2E,0x26,0xBE,0xAB};
+const char* ColumnStatistics::ascii_fingerprint = "37AA2F226C29DF25254CCCE6A7DDBAF3";
+const uint8_t ColumnStatistics::binary_fingerprint[16] = {0x37,0xAA,0x2F,0x22,0x6C,0x29,0xDF,0x25,0x25,0x4C,0xCC,0xE6,0xA7,0xDD,0xBA,0xF3};
 
 uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -4412,8 +4617,8 @@ void swap(PartitionsByExprRequest &a, Pa
   swap(a.__isset, b.__isset);
 }
 
-const char* TableStatsResult::ascii_fingerprint = "3A0CB62070A0D93EE2CE174AF08C0E92";
-const uint8_t TableStatsResult::binary_fingerprint[16] = {0x3A,0x0C,0xB6,0x20,0x70,0xA0,0xD9,0x3E,0xE2,0xCE,0x17,0x4A,0xF0,0x8C,0x0E,0x92};
+const char* TableStatsResult::ascii_fingerprint = "178DBEC75B48CDDEDB3B8338EF6FBF2F";
+const uint8_t TableStatsResult::binary_fingerprint[16] = {0x17,0x8D,0xBE,0xC7,0x5B,0x48,0xCD,0xDE,0xDB,0x3B,0x83,0x38,0xEF,0x6F,0xBF,0x2F};
 
 uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -4496,8 +4701,8 @@ void swap(TableStatsResult &a, TableStat
   swap(a.tableStats, b.tableStats);
 }
 
-const char* PartitionsStatsResult::ascii_fingerprint = "9790481369E1B27F6E70DED62CFCA4E3";
-const uint8_t PartitionsStatsResult::binary_fingerprint[16] = {0x97,0x90,0x48,0x13,0x69,0xE1,0xB2,0x7F,0x6E,0x70,0xDE,0xD6,0x2C,0xFC,0xA4,0xE3};
+const char* PartitionsStatsResult::ascii_fingerprint = "0E3D549A0384CD453E2CB90C734A6245";
+const uint8_t PartitionsStatsResult::binary_fingerprint[16] = {0x0E,0x3D,0x54,0x9A,0x03,0x84,0xCD,0x45,0x3E,0x2C,0xB9,0x0C,0x73,0x4A,0x62,0x45};
 
 uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 

Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Thu Mar 27 23:40:03 2014
@@ -1952,20 +1952,123 @@ class BinaryColumnStatsData {
 
 void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b);
 
+
+class Decimal {
+ public:
+
+  static const char* ascii_fingerprint; // = "C4DDF6759F9B17C5C380806CE743DE8E";
+  static const uint8_t binary_fingerprint[16]; // = {0xC4,0xDD,0xF6,0x75,0x9F,0x9B,0x17,0xC5,0xC3,0x80,0x80,0x6C,0xE7,0x43,0xDE,0x8E};
+
+  Decimal() : unscaled(), scale(0) {
+  }
+
+  virtual ~Decimal() throw() {}
+
+  std::string unscaled;
+  int16_t scale;
+
+  void __set_unscaled(const std::string& val) {
+    unscaled = val;
+  }
+
+  void __set_scale(const int16_t val) {
+    scale = val;
+  }
+
+  bool operator == (const Decimal & rhs) const
+  {
+    if (!(unscaled == rhs.unscaled))
+      return false;
+    if (!(scale == rhs.scale))
+      return false;
+    return true;
+  }
+  bool operator != (const Decimal &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Decimal & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Decimal &a, Decimal &b);
+
+
+class DecimalColumnStatsData {
+ public:
+
+  static const char* ascii_fingerprint; // = "3AE5C36598A014EE815B87600C3087B5";
+  static const uint8_t binary_fingerprint[16]; // = {0x3A,0xE5,0xC3,0x65,0x98,0xA0,0x14,0xEE,0x81,0x5B,0x87,0x60,0x0C,0x30,0x87,0xB5};
+
+  DecimalColumnStatsData() : numNulls(0), numDVs(0) {
+  }
+
+  virtual ~DecimalColumnStatsData() throw() {}
+
+  Decimal lowValue;
+  Decimal highValue;
+  int64_t numNulls;
+  int64_t numDVs;
+
+  void __set_lowValue(const Decimal& val) {
+    lowValue = val;
+  }
+
+  void __set_highValue(const Decimal& val) {
+    highValue = val;
+  }
+
+  void __set_numNulls(const int64_t val) {
+    numNulls = val;
+  }
+
+  void __set_numDVs(const int64_t val) {
+    numDVs = val;
+  }
+
+  bool operator == (const DecimalColumnStatsData & rhs) const
+  {
+    if (!(lowValue == rhs.lowValue))
+      return false;
+    if (!(highValue == rhs.highValue))
+      return false;
+    if (!(numNulls == rhs.numNulls))
+      return false;
+    if (!(numDVs == rhs.numDVs))
+      return false;
+    return true;
+  }
+  bool operator != (const DecimalColumnStatsData &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const DecimalColumnStatsData & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b);
+
 typedef struct _ColumnStatisticsData__isset {
-  _ColumnStatisticsData__isset() : booleanStats(false), longStats(false), doubleStats(false), stringStats(false), binaryStats(false) {}
+  _ColumnStatisticsData__isset() : booleanStats(false), longStats(false), doubleStats(false), stringStats(false), binaryStats(false), decimalStats(false) {}
   bool booleanStats;
   bool longStats;
   bool doubleStats;
   bool stringStats;
   bool binaryStats;
+  bool decimalStats;
 } _ColumnStatisticsData__isset;
 
 class ColumnStatisticsData {
  public:
 
-  static const char* ascii_fingerprint; // = "3D106F26C0761EF37E58CAFAA3F1651C";
-  static const uint8_t binary_fingerprint[16]; // = {0x3D,0x10,0x6F,0x26,0xC0,0x76,0x1E,0xF3,0x7E,0x58,0xCA,0xFA,0xA3,0xF1,0x65,0x1C};
+  static const char* ascii_fingerprint; // = "343F5865568AF7DA61829A616EB8C57C";
+  static const uint8_t binary_fingerprint[16]; // = {0x34,0x3F,0x58,0x65,0x56,0x8A,0xF7,0xDA,0x61,0x82,0x9A,0x61,0x6E,0xB8,0xC5,0x7C};
 
   ColumnStatisticsData() {
   }
@@ -1977,6 +2080,7 @@ class ColumnStatisticsData {
   DoubleColumnStatsData doubleStats;
   StringColumnStatsData stringStats;
   BinaryColumnStatsData binaryStats;
+  DecimalColumnStatsData decimalStats;
 
   _ColumnStatisticsData__isset __isset;
 
@@ -2000,6 +2104,10 @@ class ColumnStatisticsData {
     binaryStats = val;
   }
 
+  void __set_decimalStats(const DecimalColumnStatsData& val) {
+    decimalStats = val;
+  }
+
   bool operator == (const ColumnStatisticsData & rhs) const
   {
     if (!(booleanStats == rhs.booleanStats))
@@ -2012,6 +2120,8 @@ class ColumnStatisticsData {
       return false;
     if (!(binaryStats == rhs.binaryStats))
       return false;
+    if (!(decimalStats == rhs.decimalStats))
+      return false;
     return true;
   }
   bool operator != (const ColumnStatisticsData &rhs) const {
@@ -2031,8 +2141,8 @@ void swap(ColumnStatisticsData &a, Colum
 class ColumnStatisticsObj {
  public:
 
-  static const char* ascii_fingerprint; // = "DEE09584C51BCAF60824FE4509B59567";
-  static const uint8_t binary_fingerprint[16]; // = {0xDE,0xE0,0x95,0x84,0xC5,0x1B,0xCA,0xF6,0x08,0x24,0xFE,0x45,0x09,0xB5,0x95,0x67};
+  static const char* ascii_fingerprint; // = "CFDBB9DFF4F1670367EA5356861EC180";
+  static const uint8_t binary_fingerprint[16]; // = {0xCF,0xDB,0xB9,0xDF,0xF4,0xF1,0x67,0x03,0x67,0xEA,0x53,0x56,0x86,0x1E,0xC1,0x80};
 
   ColumnStatisticsObj() : colName(), colType() {
   }
@@ -2160,8 +2270,8 @@ void swap(ColumnStatisticsDesc &a, Colum
 class ColumnStatistics {
  public:
 
-  static const char* ascii_fingerprint; // = "681BDBD0CBB53373AC1C9C0C2E26BEAB";
-  static const uint8_t binary_fingerprint[16]; // = {0x68,0x1B,0xDB,0xD0,0xCB,0xB5,0x33,0x73,0xAC,0x1C,0x9C,0x0C,0x2E,0x26,0xBE,0xAB};
+  static const char* ascii_fingerprint; // = "37AA2F226C29DF25254CCCE6A7DDBAF3";
+  static const uint8_t binary_fingerprint[16]; // = {0x37,0xAA,0x2F,0x22,0x6C,0x29,0xDF,0x25,0x25,0x4C,0xCC,0xE6,0xA7,0xDD,0xBA,0xF3};
 
   ColumnStatistics() {
   }
@@ -2420,8 +2530,8 @@ void swap(PartitionsByExprRequest &a, Pa
 class TableStatsResult {
  public:
 
-  static const char* ascii_fingerprint; // = "3A0CB62070A0D93EE2CE174AF08C0E92";
-  static const uint8_t binary_fingerprint[16]; // = {0x3A,0x0C,0xB6,0x20,0x70,0xA0,0xD9,0x3E,0xE2,0xCE,0x17,0x4A,0xF0,0x8C,0x0E,0x92};
+  static const char* ascii_fingerprint; // = "178DBEC75B48CDDEDB3B8338EF6FBF2F";
+  static const uint8_t binary_fingerprint[16]; // = {0x17,0x8D,0xBE,0xC7,0x5B,0x48,0xCD,0xDE,0xDB,0x3B,0x83,0x38,0xEF,0x6F,0xBF,0x2F};
 
   TableStatsResult() {
   }
@@ -2457,8 +2567,8 @@ void swap(TableStatsResult &a, TableStat
 class PartitionsStatsResult {
  public:
 
-  static const char* ascii_fingerprint; // = "9790481369E1B27F6E70DED62CFCA4E3";
-  static const uint8_t binary_fingerprint[16]; // = {0x97,0x90,0x48,0x13,0x69,0xE1,0xB2,0x7F,0x6E,0x70,0xDE,0xD6,0x2C,0xFC,0xA4,0xE3};
+  static const char* ascii_fingerprint; // = "0E3D549A0384CD453E2CB90C734A6245";
+  static const uint8_t binary_fingerprint[16]; // = {0x0E,0x3D,0x54,0x9A,0x03,0x84,0xCD,0x45,0x3E,0x2C,0xB9,0x0C,0x73,0x4A,0x62,0x45};
 
   PartitionsStatsResult() {
   }

Modified: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ColumnStatisticsData.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ColumnStatisticsData.java?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ColumnStatisticsData.java (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ColumnStatisticsData.java Thu Mar 27 23:40:03 2014
@@ -38,6 +38,7 @@ public class ColumnStatisticsData extend
   private static final org.apache.thrift.protocol.TField DOUBLE_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("doubleStats", org.apache.thrift.protocol.TType.STRUCT, (short)3);
   private static final org.apache.thrift.protocol.TField STRING_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("stringStats", org.apache.thrift.protocol.TType.STRUCT, (short)4);
   private static final org.apache.thrift.protocol.TField BINARY_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("binaryStats", org.apache.thrift.protocol.TType.STRUCT, (short)5);
+  private static final org.apache.thrift.protocol.TField DECIMAL_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("decimalStats", org.apache.thrift.protocol.TType.STRUCT, (short)6);
 
   /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
   public enum _Fields implements org.apache.thrift.TFieldIdEnum {
@@ -45,7 +46,8 @@ public class ColumnStatisticsData extend
     LONG_STATS((short)2, "longStats"),
     DOUBLE_STATS((short)3, "doubleStats"),
     STRING_STATS((short)4, "stringStats"),
-    BINARY_STATS((short)5, "binaryStats");
+    BINARY_STATS((short)5, "binaryStats"),
+    DECIMAL_STATS((short)6, "decimalStats");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
@@ -70,6 +72,8 @@ public class ColumnStatisticsData extend
           return STRING_STATS;
         case 5: // BINARY_STATS
           return BINARY_STATS;
+        case 6: // DECIMAL_STATS
+          return DECIMAL_STATS;
         default:
           return null;
       }
@@ -122,6 +126,8 @@ public class ColumnStatisticsData extend
         new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, StringColumnStatsData.class)));
     tmpMap.put(_Fields.BINARY_STATS, new org.apache.thrift.meta_data.FieldMetaData("binaryStats", org.apache.thrift.TFieldRequirementType.DEFAULT, 
         new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, BinaryColumnStatsData.class)));
+    tmpMap.put(_Fields.DECIMAL_STATS, new org.apache.thrift.meta_data.FieldMetaData("decimalStats", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DecimalColumnStatsData.class)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ColumnStatisticsData.class, metaDataMap);
   }
@@ -171,6 +177,12 @@ public class ColumnStatisticsData extend
     return x;
   }
 
+  public static ColumnStatisticsData decimalStats(DecimalColumnStatsData value) {
+    ColumnStatisticsData x = new ColumnStatisticsData();
+    x.setDecimalStats(value);
+    return x;
+  }
+
 
   @Override
   protected void checkType(_Fields setField, Object value) throws ClassCastException {
@@ -200,6 +212,11 @@ public class ColumnStatisticsData extend
           break;
         }
         throw new ClassCastException("Was expecting value of type BinaryColumnStatsData for field 'binaryStats', but got " + value.getClass().getSimpleName());
+      case DECIMAL_STATS:
+        if (value instanceof DecimalColumnStatsData) {
+          break;
+        }
+        throw new ClassCastException("Was expecting value of type DecimalColumnStatsData for field 'decimalStats', but got " + value.getClass().getSimpleName());
       default:
         throw new IllegalArgumentException("Unknown field id " + setField);
     }
@@ -260,6 +277,16 @@ public class ColumnStatisticsData extend
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
             return null;
           }
+        case DECIMAL_STATS:
+          if (field.type == DECIMAL_STATS_FIELD_DESC.type) {
+            DecimalColumnStatsData decimalStats;
+            decimalStats = new DecimalColumnStatsData();
+            decimalStats.read(iprot);
+            return decimalStats;
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            return null;
+          }
         default:
           throw new IllegalStateException("setField wasn't null, but didn't match any of the case statements!");
       }
@@ -291,6 +318,10 @@ public class ColumnStatisticsData extend
         BinaryColumnStatsData binaryStats = (BinaryColumnStatsData)value_;
         binaryStats.write(oprot);
         return;
+      case DECIMAL_STATS:
+        DecimalColumnStatsData decimalStats = (DecimalColumnStatsData)value_;
+        decimalStats.write(oprot);
+        return;
       default:
         throw new IllegalStateException("Cannot write union with unknown field " + setField_);
     }
@@ -326,6 +357,11 @@ public class ColumnStatisticsData extend
           binaryStats = new BinaryColumnStatsData();
           binaryStats.read(iprot);
           return binaryStats;
+        case DECIMAL_STATS:
+          DecimalColumnStatsData decimalStats;
+          decimalStats = new DecimalColumnStatsData();
+          decimalStats.read(iprot);
+          return decimalStats;
         default:
           throw new IllegalStateException("setField wasn't null, but didn't match any of the case statements!");
       }
@@ -357,6 +393,10 @@ public class ColumnStatisticsData extend
         BinaryColumnStatsData binaryStats = (BinaryColumnStatsData)value_;
         binaryStats.write(oprot);
         return;
+      case DECIMAL_STATS:
+        DecimalColumnStatsData decimalStats = (DecimalColumnStatsData)value_;
+        decimalStats.write(oprot);
+        return;
       default:
         throw new IllegalStateException("Cannot write union with unknown field " + setField_);
     }
@@ -375,6 +415,8 @@ public class ColumnStatisticsData extend
         return STRING_STATS_FIELD_DESC;
       case BINARY_STATS:
         return BINARY_STATS_FIELD_DESC;
+      case DECIMAL_STATS:
+        return DECIMAL_STATS_FIELD_DESC;
       default:
         throw new IllegalArgumentException("Unknown field id " + setField);
     }
@@ -465,6 +507,20 @@ public class ColumnStatisticsData extend
     value_ = value;
   }
 
+  public DecimalColumnStatsData getDecimalStats() {
+    if (getSetField() == _Fields.DECIMAL_STATS) {
+      return (DecimalColumnStatsData)getFieldValue();
+    } else {
+      throw new RuntimeException("Cannot get field 'decimalStats' because union is currently set to " + getFieldDesc(getSetField()).name);
+    }
+  }
+
+  public void setDecimalStats(DecimalColumnStatsData value) {
+    if (value == null) throw new NullPointerException();
+    setField_ = _Fields.DECIMAL_STATS;
+    value_ = value;
+  }
+
   public boolean isSetBooleanStats() {
     return setField_ == _Fields.BOOLEAN_STATS;
   }
@@ -490,6 +546,11 @@ public class ColumnStatisticsData extend
   }
 
 
+  public boolean isSetDecimalStats() {
+    return setField_ == _Fields.DECIMAL_STATS;
+  }
+
+
   public boolean equals(Object other) {
     if (other instanceof ColumnStatisticsData) {
       return equals((ColumnStatisticsData)other);

Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Decimal.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Decimal.java?rev=1582546&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Decimal.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Decimal.java Thu Mar 27 23:40:03 2014
@@ -0,0 +1,494 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Decimal implements org.apache.thrift.TBase<Decimal, Decimal._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Decimal");
+
+  private static final org.apache.thrift.protocol.TField UNSCALED_FIELD_DESC = new org.apache.thrift.protocol.TField("unscaled", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField SCALE_FIELD_DESC = new org.apache.thrift.protocol.TField("scale", org.apache.thrift.protocol.TType.I16, (short)3);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new DecimalStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new DecimalTupleSchemeFactory());
+  }
+
+  private ByteBuffer unscaled; // required
+  private short scale; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    UNSCALED((short)1, "unscaled"),
+    SCALE((short)3, "scale");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // UNSCALED
+          return UNSCALED;
+        case 3: // SCALE
+          return SCALE;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __SCALE_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.UNSCALED, new org.apache.thrift.meta_data.FieldMetaData("unscaled", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
+    tmpMap.put(_Fields.SCALE, new org.apache.thrift.meta_data.FieldMetaData("scale", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Decimal.class, metaDataMap);
+  }
+
+  public Decimal() {
+  }
+
+  public Decimal(
+    ByteBuffer unscaled,
+    short scale)
+  {
+    this();
+    this.unscaled = unscaled;
+    this.scale = scale;
+    setScaleIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public Decimal(Decimal other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetUnscaled()) {
+      this.unscaled = org.apache.thrift.TBaseHelper.copyBinary(other.unscaled);
+;
+    }
+    this.scale = other.scale;
+  }
+
+  public Decimal deepCopy() {
+    return new Decimal(this);
+  }
+
+  @Override
+  public void clear() {
+    this.unscaled = null;
+    setScaleIsSet(false);
+    this.scale = 0;
+  }
+
+  public byte[] getUnscaled() {
+    setUnscaled(org.apache.thrift.TBaseHelper.rightSize(unscaled));
+    return unscaled == null ? null : unscaled.array();
+  }
+
+  public ByteBuffer bufferForUnscaled() {
+    return unscaled;
+  }
+
+  public void setUnscaled(byte[] unscaled) {
+    setUnscaled(unscaled == null ? (ByteBuffer)null : ByteBuffer.wrap(unscaled));
+  }
+
+  public void setUnscaled(ByteBuffer unscaled) {
+    this.unscaled = unscaled;
+  }
+
+  public void unsetUnscaled() {
+    this.unscaled = null;
+  }
+
+  /** Returns true if field unscaled is set (has been assigned a value) and false otherwise */
+  public boolean isSetUnscaled() {
+    return this.unscaled != null;
+  }
+
+  public void setUnscaledIsSet(boolean value) {
+    if (!value) {
+      this.unscaled = null;
+    }
+  }
+
+  public short getScale() {
+    return this.scale;
+  }
+
+  public void setScale(short scale) {
+    this.scale = scale;
+    setScaleIsSet(true);
+  }
+
+  public void unsetScale() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCALE_ISSET_ID);
+  }
+
+  /** Returns true if field scale is set (has been assigned a value) and false otherwise */
+  public boolean isSetScale() {
+    return EncodingUtils.testBit(__isset_bitfield, __SCALE_ISSET_ID);
+  }
+
+  public void setScaleIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCALE_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case UNSCALED:
+      if (value == null) {
+        unsetUnscaled();
+      } else {
+        setUnscaled((ByteBuffer)value);
+      }
+      break;
+
+    case SCALE:
+      if (value == null) {
+        unsetScale();
+      } else {
+        setScale((Short)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case UNSCALED:
+      return getUnscaled();
+
+    case SCALE:
+      return Short.valueOf(getScale());
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case UNSCALED:
+      return isSetUnscaled();
+    case SCALE:
+      return isSetScale();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof Decimal)
+      return this.equals((Decimal)that);
+    return false;
+  }
+
+  public boolean equals(Decimal that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_unscaled = true && this.isSetUnscaled();
+    boolean that_present_unscaled = true && that.isSetUnscaled();
+    if (this_present_unscaled || that_present_unscaled) {
+      if (!(this_present_unscaled && that_present_unscaled))
+        return false;
+      if (!this.unscaled.equals(that.unscaled))
+        return false;
+    }
+
+    boolean this_present_scale = true;
+    boolean that_present_scale = true;
+    if (this_present_scale || that_present_scale) {
+      if (!(this_present_scale && that_present_scale))
+        return false;
+      if (this.scale != that.scale)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    HashCodeBuilder builder = new HashCodeBuilder();
+
+    boolean present_unscaled = true && (isSetUnscaled());
+    builder.append(present_unscaled);
+    if (present_unscaled)
+      builder.append(unscaled);
+
+    boolean present_scale = true;
+    builder.append(present_scale);
+    if (present_scale)
+      builder.append(scale);
+
+    return builder.toHashCode();
+  }
+
+  public int compareTo(Decimal other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    Decimal typedOther = (Decimal)other;
+
+    lastComparison = Boolean.valueOf(isSetUnscaled()).compareTo(typedOther.isSetUnscaled());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetUnscaled()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.unscaled, typedOther.unscaled);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetScale()).compareTo(typedOther.isSetScale());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetScale()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scale, typedOther.scale);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("Decimal(");
+    boolean first = true;
+
+    sb.append("unscaled:");
+    if (this.unscaled == null) {
+      sb.append("null");
+    } else {
+      org.apache.thrift.TBaseHelper.toString(this.unscaled, sb);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("scale:");
+    sb.append(this.scale);
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetUnscaled()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'unscaled' is unset! Struct:" + toString());
+    }
+
+    if (!isSetScale()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'scale' is unset! Struct:" + toString());
+    }
+
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class DecimalStandardSchemeFactory implements SchemeFactory {
+    public DecimalStandardScheme getScheme() {
+      return new DecimalStandardScheme();
+    }
+  }
+
+  private static class DecimalStandardScheme extends StandardScheme<Decimal> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, Decimal struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // UNSCALED
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.unscaled = iprot.readBinary();
+              struct.setUnscaledIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // SCALE
+            if (schemeField.type == org.apache.thrift.protocol.TType.I16) {
+              struct.scale = iprot.readI16();
+              struct.setScaleIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, Decimal struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.unscaled != null) {
+        oprot.writeFieldBegin(UNSCALED_FIELD_DESC);
+        oprot.writeBinary(struct.unscaled);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(SCALE_FIELD_DESC);
+      oprot.writeI16(struct.scale);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class DecimalTupleSchemeFactory implements SchemeFactory {
+    public DecimalTupleScheme getScheme() {
+      return new DecimalTupleScheme();
+    }
+  }
+
+  private static class DecimalTupleScheme extends TupleScheme<Decimal> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, Decimal struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeBinary(struct.unscaled);
+      oprot.writeI16(struct.scale);
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, Decimal struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.unscaled = iprot.readBinary();
+      struct.setUnscaledIsSet(true);
+      struct.scale = iprot.readI16();
+      struct.setScaleIsSet(true);
+    }
+  }
+
+}
+

Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DecimalColumnStatsData.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DecimalColumnStatsData.java?rev=1582546&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DecimalColumnStatsData.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DecimalColumnStatsData.java Thu Mar 27 23:40:03 2014
@@ -0,0 +1,690 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DecimalColumnStatsData implements org.apache.thrift.TBase<DecimalColumnStatsData, DecimalColumnStatsData._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("DecimalColumnStatsData");
+
+  private static final org.apache.thrift.protocol.TField LOW_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("lowValue", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+  private static final org.apache.thrift.protocol.TField HIGH_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("highValue", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+  private static final org.apache.thrift.protocol.TField NUM_NULLS_FIELD_DESC = new org.apache.thrift.protocol.TField("numNulls", org.apache.thrift.protocol.TType.I64, (short)3);
+  private static final org.apache.thrift.protocol.TField NUM_DVS_FIELD_DESC = new org.apache.thrift.protocol.TField("numDVs", org.apache.thrift.protocol.TType.I64, (short)4);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new DecimalColumnStatsDataStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new DecimalColumnStatsDataTupleSchemeFactory());
+  }
+
+  private Decimal lowValue; // required
+  private Decimal highValue; // required
+  private long numNulls; // required
+  private long numDVs; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    LOW_VALUE((short)1, "lowValue"),
+    HIGH_VALUE((short)2, "highValue"),
+    NUM_NULLS((short)3, "numNulls"),
+    NUM_DVS((short)4, "numDVs");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // LOW_VALUE
+          return LOW_VALUE;
+        case 2: // HIGH_VALUE
+          return HIGH_VALUE;
+        case 3: // NUM_NULLS
+          return NUM_NULLS;
+        case 4: // NUM_DVS
+          return NUM_DVS;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __NUMNULLS_ISSET_ID = 0;
+  private static final int __NUMDVS_ISSET_ID = 1;
+  private byte __isset_bitfield = 0;
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.LOW_VALUE, new org.apache.thrift.meta_data.FieldMetaData("lowValue", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Decimal.class)));
+    tmpMap.put(_Fields.HIGH_VALUE, new org.apache.thrift.meta_data.FieldMetaData("highValue", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Decimal.class)));
+    tmpMap.put(_Fields.NUM_NULLS, new org.apache.thrift.meta_data.FieldMetaData("numNulls", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.NUM_DVS, new org.apache.thrift.meta_data.FieldMetaData("numDVs", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DecimalColumnStatsData.class, metaDataMap);
+  }
+
+  public DecimalColumnStatsData() {
+  }
+
+  public DecimalColumnStatsData(
+    Decimal lowValue,
+    Decimal highValue,
+    long numNulls,
+    long numDVs)
+  {
+    this();
+    this.lowValue = lowValue;
+    this.highValue = highValue;
+    this.numNulls = numNulls;
+    setNumNullsIsSet(true);
+    this.numDVs = numDVs;
+    setNumDVsIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public DecimalColumnStatsData(DecimalColumnStatsData other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetLowValue()) {
+      this.lowValue = new Decimal(other.lowValue);
+    }
+    if (other.isSetHighValue()) {
+      this.highValue = new Decimal(other.highValue);
+    }
+    this.numNulls = other.numNulls;
+    this.numDVs = other.numDVs;
+  }
+
+  public DecimalColumnStatsData deepCopy() {
+    return new DecimalColumnStatsData(this);
+  }
+
+  @Override
+  public void clear() {
+    this.lowValue = null;
+    this.highValue = null;
+    setNumNullsIsSet(false);
+    this.numNulls = 0;
+    setNumDVsIsSet(false);
+    this.numDVs = 0;
+  }
+
+  public Decimal getLowValue() {
+    return this.lowValue;
+  }
+
+  public void setLowValue(Decimal lowValue) {
+    this.lowValue = lowValue;
+  }
+
+  public void unsetLowValue() {
+    this.lowValue = null;
+  }
+
+  /** Returns true if field lowValue is set (has been assigned a value) and false otherwise */
+  public boolean isSetLowValue() {
+    return this.lowValue != null;
+  }
+
+  public void setLowValueIsSet(boolean value) {
+    if (!value) {
+      this.lowValue = null;
+    }
+  }
+
+  public Decimal getHighValue() {
+    return this.highValue;
+  }
+
+  public void setHighValue(Decimal highValue) {
+    this.highValue = highValue;
+  }
+
+  public void unsetHighValue() {
+    this.highValue = null;
+  }
+
+  /** Returns true if field highValue is set (has been assigned a value) and false otherwise */
+  public boolean isSetHighValue() {
+    return this.highValue != null;
+  }
+
+  public void setHighValueIsSet(boolean value) {
+    if (!value) {
+      this.highValue = null;
+    }
+  }
+
+  public long getNumNulls() {
+    return this.numNulls;
+  }
+
+  public void setNumNulls(long numNulls) {
+    this.numNulls = numNulls;
+    setNumNullsIsSet(true);
+  }
+
+  public void unsetNumNulls() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __NUMNULLS_ISSET_ID);
+  }
+
+  /** Returns true if field numNulls is set (has been assigned a value) and false otherwise */
+  public boolean isSetNumNulls() {
+    return EncodingUtils.testBit(__isset_bitfield, __NUMNULLS_ISSET_ID);
+  }
+
+  public void setNumNullsIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __NUMNULLS_ISSET_ID, value);
+  }
+
+  public long getNumDVs() {
+    return this.numDVs;
+  }
+
+  public void setNumDVs(long numDVs) {
+    this.numDVs = numDVs;
+    setNumDVsIsSet(true);
+  }
+
+  public void unsetNumDVs() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __NUMDVS_ISSET_ID);
+  }
+
+  /** Returns true if field numDVs is set (has been assigned a value) and false otherwise */
+  public boolean isSetNumDVs() {
+    return EncodingUtils.testBit(__isset_bitfield, __NUMDVS_ISSET_ID);
+  }
+
+  public void setNumDVsIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __NUMDVS_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case LOW_VALUE:
+      if (value == null) {
+        unsetLowValue();
+      } else {
+        setLowValue((Decimal)value);
+      }
+      break;
+
+    case HIGH_VALUE:
+      if (value == null) {
+        unsetHighValue();
+      } else {
+        setHighValue((Decimal)value);
+      }
+      break;
+
+    case NUM_NULLS:
+      if (value == null) {
+        unsetNumNulls();
+      } else {
+        setNumNulls((Long)value);
+      }
+      break;
+
+    case NUM_DVS:
+      if (value == null) {
+        unsetNumDVs();
+      } else {
+        setNumDVs((Long)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case LOW_VALUE:
+      return getLowValue();
+
+    case HIGH_VALUE:
+      return getHighValue();
+
+    case NUM_NULLS:
+      return Long.valueOf(getNumNulls());
+
+    case NUM_DVS:
+      return Long.valueOf(getNumDVs());
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case LOW_VALUE:
+      return isSetLowValue();
+    case HIGH_VALUE:
+      return isSetHighValue();
+    case NUM_NULLS:
+      return isSetNumNulls();
+    case NUM_DVS:
+      return isSetNumDVs();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof DecimalColumnStatsData)
+      return this.equals((DecimalColumnStatsData)that);
+    return false;
+  }
+
+  public boolean equals(DecimalColumnStatsData that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_lowValue = true && this.isSetLowValue();
+    boolean that_present_lowValue = true && that.isSetLowValue();
+    if (this_present_lowValue || that_present_lowValue) {
+      if (!(this_present_lowValue && that_present_lowValue))
+        return false;
+      if (!this.lowValue.equals(that.lowValue))
+        return false;
+    }
+
+    boolean this_present_highValue = true && this.isSetHighValue();
+    boolean that_present_highValue = true && that.isSetHighValue();
+    if (this_present_highValue || that_present_highValue) {
+      if (!(this_present_highValue && that_present_highValue))
+        return false;
+      if (!this.highValue.equals(that.highValue))
+        return false;
+    }
+
+    boolean this_present_numNulls = true;
+    boolean that_present_numNulls = true;
+    if (this_present_numNulls || that_present_numNulls) {
+      if (!(this_present_numNulls && that_present_numNulls))
+        return false;
+      if (this.numNulls != that.numNulls)
+        return false;
+    }
+
+    boolean this_present_numDVs = true;
+    boolean that_present_numDVs = true;
+    if (this_present_numDVs || that_present_numDVs) {
+      if (!(this_present_numDVs && that_present_numDVs))
+        return false;
+      if (this.numDVs != that.numDVs)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    HashCodeBuilder builder = new HashCodeBuilder();
+
+    boolean present_lowValue = true && (isSetLowValue());
+    builder.append(present_lowValue);
+    if (present_lowValue)
+      builder.append(lowValue);
+
+    boolean present_highValue = true && (isSetHighValue());
+    builder.append(present_highValue);
+    if (present_highValue)
+      builder.append(highValue);
+
+    boolean present_numNulls = true;
+    builder.append(present_numNulls);
+    if (present_numNulls)
+      builder.append(numNulls);
+
+    boolean present_numDVs = true;
+    builder.append(present_numDVs);
+    if (present_numDVs)
+      builder.append(numDVs);
+
+    return builder.toHashCode();
+  }
+
+  public int compareTo(DecimalColumnStatsData other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    DecimalColumnStatsData typedOther = (DecimalColumnStatsData)other;
+
+    lastComparison = Boolean.valueOf(isSetLowValue()).compareTo(typedOther.isSetLowValue());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetLowValue()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lowValue, typedOther.lowValue);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetHighValue()).compareTo(typedOther.isSetHighValue());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetHighValue()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.highValue, typedOther.highValue);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetNumNulls()).compareTo(typedOther.isSetNumNulls());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetNumNulls()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numNulls, typedOther.numNulls);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetNumDVs()).compareTo(typedOther.isSetNumDVs());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetNumDVs()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numDVs, typedOther.numDVs);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("DecimalColumnStatsData(");
+    boolean first = true;
+
+    sb.append("lowValue:");
+    if (this.lowValue == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.lowValue);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("highValue:");
+    if (this.highValue == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.highValue);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("numNulls:");
+    sb.append(this.numNulls);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("numDVs:");
+    sb.append(this.numDVs);
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetLowValue()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'lowValue' is unset! Struct:" + toString());
+    }
+
+    if (!isSetHighValue()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'highValue' is unset! Struct:" + toString());
+    }
+
+    if (!isSetNumNulls()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'numNulls' is unset! Struct:" + toString());
+    }
+
+    if (!isSetNumDVs()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'numDVs' is unset! Struct:" + toString());
+    }
+
+    // check for sub-struct validity
+    if (lowValue != null) {
+      lowValue.validate();
+    }
+    if (highValue != null) {
+      highValue.validate();
+    }
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class DecimalColumnStatsDataStandardSchemeFactory implements SchemeFactory {
+    public DecimalColumnStatsDataStandardScheme getScheme() {
+      return new DecimalColumnStatsDataStandardScheme();
+    }
+  }
+
+  private static class DecimalColumnStatsDataStandardScheme extends StandardScheme<DecimalColumnStatsData> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, DecimalColumnStatsData struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // LOW_VALUE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.lowValue = new Decimal();
+              struct.lowValue.read(iprot);
+              struct.setLowValueIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // HIGH_VALUE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.highValue = new Decimal();
+              struct.highValue.read(iprot);
+              struct.setHighValueIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // NUM_NULLS
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.numNulls = iprot.readI64();
+              struct.setNumNullsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // NUM_DVS
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.numDVs = iprot.readI64();
+              struct.setNumDVsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, DecimalColumnStatsData struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.lowValue != null) {
+        oprot.writeFieldBegin(LOW_VALUE_FIELD_DESC);
+        struct.lowValue.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      if (struct.highValue != null) {
+        oprot.writeFieldBegin(HIGH_VALUE_FIELD_DESC);
+        struct.highValue.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(NUM_NULLS_FIELD_DESC);
+      oprot.writeI64(struct.numNulls);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(NUM_DVS_FIELD_DESC);
+      oprot.writeI64(struct.numDVs);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class DecimalColumnStatsDataTupleSchemeFactory implements SchemeFactory {
+    public DecimalColumnStatsDataTupleScheme getScheme() {
+      return new DecimalColumnStatsDataTupleScheme();
+    }
+  }
+
+  private static class DecimalColumnStatsDataTupleScheme extends TupleScheme<DecimalColumnStatsData> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, DecimalColumnStatsData struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      struct.lowValue.write(oprot);
+      struct.highValue.write(oprot);
+      oprot.writeI64(struct.numNulls);
+      oprot.writeI64(struct.numDVs);
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, DecimalColumnStatsData struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.lowValue = new Decimal();
+      struct.lowValue.read(iprot);
+      struct.setLowValueIsSet(true);
+      struct.highValue = new Decimal();
+      struct.highValue.read(iprot);
+      struct.setHighValueIsSet(true);
+      struct.numNulls = iprot.readI64();
+      struct.setNumNullsIsSet(true);
+      struct.numDVs = iprot.readI64();
+      struct.setNumDVsIsSet(true);
+    }
+  }
+
+}
+

Modified: hive/trunk/metastore/src/gen/thrift/gen-php/metastore/Types.php
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-php/metastore/Types.php?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-php/metastore/Types.php (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-php/metastore/Types.php Thu Mar 27 23:40:03 2014
@@ -4631,6 +4631,240 @@ class BinaryColumnStatsData {
 
 }
 
+class Decimal {
+  static $_TSPEC;
+
+  public $unscaled = null;
+  public $scale = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'unscaled',
+          'type' => TType::STRING,
+          ),
+        3 => array(
+          'var' => 'scale',
+          'type' => TType::I16,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['unscaled'])) {
+        $this->unscaled = $vals['unscaled'];
+      }
+      if (isset($vals['scale'])) {
+        $this->scale = $vals['scale'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'Decimal';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->unscaled);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::I16) {
+            $xfer += $input->readI16($this->scale);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('Decimal');
+    if ($this->unscaled !== null) {
+      $xfer += $output->writeFieldBegin('unscaled', TType::STRING, 1);
+      $xfer += $output->writeString($this->unscaled);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->scale !== null) {
+      $xfer += $output->writeFieldBegin('scale', TType::I16, 3);
+      $xfer += $output->writeI16($this->scale);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class DecimalColumnStatsData {
+  static $_TSPEC;
+
+  public $lowValue = null;
+  public $highValue = null;
+  public $numNulls = null;
+  public $numDVs = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'lowValue',
+          'type' => TType::STRUCT,
+          'class' => '\metastore\Decimal',
+          ),
+        2 => array(
+          'var' => 'highValue',
+          'type' => TType::STRUCT,
+          'class' => '\metastore\Decimal',
+          ),
+        3 => array(
+          'var' => 'numNulls',
+          'type' => TType::I64,
+          ),
+        4 => array(
+          'var' => 'numDVs',
+          'type' => TType::I64,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['lowValue'])) {
+        $this->lowValue = $vals['lowValue'];
+      }
+      if (isset($vals['highValue'])) {
+        $this->highValue = $vals['highValue'];
+      }
+      if (isset($vals['numNulls'])) {
+        $this->numNulls = $vals['numNulls'];
+      }
+      if (isset($vals['numDVs'])) {
+        $this->numDVs = $vals['numDVs'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'DecimalColumnStatsData';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRUCT) {
+            $this->lowValue = new \metastore\Decimal();
+            $xfer += $this->lowValue->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRUCT) {
+            $this->highValue = new \metastore\Decimal();
+            $xfer += $this->highValue->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::I64) {
+            $xfer += $input->readI64($this->numNulls);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 4:
+          if ($ftype == TType::I64) {
+            $xfer += $input->readI64($this->numDVs);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('DecimalColumnStatsData');
+    if ($this->lowValue !== null) {
+      if (!is_object($this->lowValue)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('lowValue', TType::STRUCT, 1);
+      $xfer += $this->lowValue->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->highValue !== null) {
+      if (!is_object($this->highValue)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('highValue', TType::STRUCT, 2);
+      $xfer += $this->highValue->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->numNulls !== null) {
+      $xfer += $output->writeFieldBegin('numNulls', TType::I64, 3);
+      $xfer += $output->writeI64($this->numNulls);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->numDVs !== null) {
+      $xfer += $output->writeFieldBegin('numDVs', TType::I64, 4);
+      $xfer += $output->writeI64($this->numDVs);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
 class ColumnStatisticsData {
   static $_TSPEC;
 
@@ -4639,6 +4873,7 @@ class ColumnStatisticsData {
   public $doubleStats = null;
   public $stringStats = null;
   public $binaryStats = null;
+  public $decimalStats = null;
 
   public function __construct($vals=null) {
     if (!isset(self::$_TSPEC)) {
@@ -4668,6 +4903,11 @@ class ColumnStatisticsData {
           'type' => TType::STRUCT,
           'class' => '\metastore\BinaryColumnStatsData',
           ),
+        6 => array(
+          'var' => 'decimalStats',
+          'type' => TType::STRUCT,
+          'class' => '\metastore\DecimalColumnStatsData',
+          ),
         );
     }
     if (is_array($vals)) {
@@ -4686,6 +4926,9 @@ class ColumnStatisticsData {
       if (isset($vals['binaryStats'])) {
         $this->binaryStats = $vals['binaryStats'];
       }
+      if (isset($vals['decimalStats'])) {
+        $this->decimalStats = $vals['decimalStats'];
+      }
     }
   }
 
@@ -4748,6 +4991,14 @@ class ColumnStatisticsData {
             $xfer += $input->skip($ftype);
           }
           break;
+        case 6:
+          if ($ftype == TType::STRUCT) {
+            $this->decimalStats = new \metastore\DecimalColumnStatsData();
+            $xfer += $this->decimalStats->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
         default:
           $xfer += $input->skip($ftype);
           break;
@@ -4801,6 +5052,14 @@ class ColumnStatisticsData {
       $xfer += $this->binaryStats->write($output);
       $xfer += $output->writeFieldEnd();
     }
+    if ($this->decimalStats !== null) {
+      if (!is_object($this->decimalStats)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('decimalStats', TType::STRUCT, 6);
+      $xfer += $this->decimalStats->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
     $xfer += $output->writeFieldStop();
     $xfer += $output->writeStructEnd();
     return $xfer;

Modified: hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py?rev=1582546&r1=1582545&r2=1582546&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py Thu Mar 27 23:40:03 2014
@@ -3106,6 +3106,189 @@ class BinaryColumnStatsData:
   def __ne__(self, other):
     return not (self == other)
 
+class Decimal:
+  """
+  Attributes:
+   - unscaled
+   - scale
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'unscaled', None, None, ), # 1
+    None, # 2
+    (3, TType.I16, 'scale', None, None, ), # 3
+  )
+
+  def __init__(self, unscaled=None, scale=None,):
+    self.unscaled = unscaled
+    self.scale = scale
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.unscaled = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I16:
+          self.scale = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('Decimal')
+    if self.unscaled is not None:
+      oprot.writeFieldBegin('unscaled', TType.STRING, 1)
+      oprot.writeString(self.unscaled)
+      oprot.writeFieldEnd()
+    if self.scale is not None:
+      oprot.writeFieldBegin('scale', TType.I16, 3)
+      oprot.writeI16(self.scale)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.unscaled is None:
+      raise TProtocol.TProtocolException(message='Required field unscaled is unset!')
+    if self.scale is None:
+      raise TProtocol.TProtocolException(message='Required field scale is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class DecimalColumnStatsData:
+  """
+  Attributes:
+   - lowValue
+   - highValue
+   - numNulls
+   - numDVs
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'lowValue', (Decimal, Decimal.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'highValue', (Decimal, Decimal.thrift_spec), None, ), # 2
+    (3, TType.I64, 'numNulls', None, None, ), # 3
+    (4, TType.I64, 'numDVs', None, None, ), # 4
+  )
+
+  def __init__(self, lowValue=None, highValue=None, numNulls=None, numDVs=None,):
+    self.lowValue = lowValue
+    self.highValue = highValue
+    self.numNulls = numNulls
+    self.numDVs = numDVs
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.lowValue = Decimal()
+          self.lowValue.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.highValue = Decimal()
+          self.highValue.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.numNulls = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I64:
+          self.numDVs = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('DecimalColumnStatsData')
+    if self.lowValue is not None:
+      oprot.writeFieldBegin('lowValue', TType.STRUCT, 1)
+      self.lowValue.write(oprot)
+      oprot.writeFieldEnd()
+    if self.highValue is not None:
+      oprot.writeFieldBegin('highValue', TType.STRUCT, 2)
+      self.highValue.write(oprot)
+      oprot.writeFieldEnd()
+    if self.numNulls is not None:
+      oprot.writeFieldBegin('numNulls', TType.I64, 3)
+      oprot.writeI64(self.numNulls)
+      oprot.writeFieldEnd()
+    if self.numDVs is not None:
+      oprot.writeFieldBegin('numDVs', TType.I64, 4)
+      oprot.writeI64(self.numDVs)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.lowValue is None:
+      raise TProtocol.TProtocolException(message='Required field lowValue is unset!')
+    if self.highValue is None:
+      raise TProtocol.TProtocolException(message='Required field highValue is unset!')
+    if self.numNulls is None:
+      raise TProtocol.TProtocolException(message='Required field numNulls is unset!')
+    if self.numDVs is None:
+      raise TProtocol.TProtocolException(message='Required field numDVs is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
 class ColumnStatisticsData:
   """
   Attributes:
@@ -3114,6 +3297,7 @@ class ColumnStatisticsData:
    - doubleStats
    - stringStats
    - binaryStats
+   - decimalStats
   """
 
   thrift_spec = (
@@ -3123,14 +3307,16 @@ class ColumnStatisticsData:
     (3, TType.STRUCT, 'doubleStats', (DoubleColumnStatsData, DoubleColumnStatsData.thrift_spec), None, ), # 3
     (4, TType.STRUCT, 'stringStats', (StringColumnStatsData, StringColumnStatsData.thrift_spec), None, ), # 4
     (5, TType.STRUCT, 'binaryStats', (BinaryColumnStatsData, BinaryColumnStatsData.thrift_spec), None, ), # 5
+    (6, TType.STRUCT, 'decimalStats', (DecimalColumnStatsData, DecimalColumnStatsData.thrift_spec), None, ), # 6
   )
 
-  def __init__(self, booleanStats=None, longStats=None, doubleStats=None, stringStats=None, binaryStats=None,):
+  def __init__(self, booleanStats=None, longStats=None, doubleStats=None, stringStats=None, binaryStats=None, decimalStats=None,):
     self.booleanStats = booleanStats
     self.longStats = longStats
     self.doubleStats = doubleStats
     self.stringStats = stringStats
     self.binaryStats = binaryStats
+    self.decimalStats = decimalStats
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -3171,6 +3357,12 @@ class ColumnStatisticsData:
           self.binaryStats.read(iprot)
         else:
           iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.STRUCT:
+          self.decimalStats = DecimalColumnStatsData()
+          self.decimalStats.read(iprot)
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -3201,6 +3393,10 @@ class ColumnStatisticsData:
       oprot.writeFieldBegin('binaryStats', TType.STRUCT, 5)
       self.binaryStats.write(oprot)
       oprot.writeFieldEnd()
+    if self.decimalStats is not None:
+      oprot.writeFieldBegin('decimalStats', TType.STRUCT, 6)
+      self.decimalStats.write(oprot)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 



Mime
View raw message