You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by cw...@apache.org on 2012/11/07 05:55:04 UTC
svn commit: r1406465 [4/15] - in /hive/trunk:
common/src/java/org/apache/hadoop/hive/conf/ conf/ 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/t...
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=1406465&r1=1406464&r2=1406465&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 Wed Nov 7 04:55:00 2012
@@ -2269,10 +2269,771 @@ uint32_t Index::write(::apache::thrift::
return xfer;
}
-const char* Schema::ascii_fingerprint = "5CFEE46C975F4E2368D905109B8E3B5B";
-const uint8_t Schema::binary_fingerprint[16] = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B};
+const char* BooleanColumnStatsData::ascii_fingerprint = "EA2D65F1E0BB78760205682082304B41";
+const uint8_t BooleanColumnStatsData::binary_fingerprint[16] = {0xEA,0x2D,0x65,0xF1,0xE0,0xBB,0x78,0x76,0x02,0x05,0x68,0x20,0x82,0x30,0x4B,0x41};
+
+uint32_t BooleanColumnStatsData::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_numTrues = false;
+ bool isset_numFalses = false;
+ bool isset_numNulls = 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_I64) {
+ xfer += iprot->readI64(this->numTrues);
+ isset_numTrues = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->numFalses);
+ isset_numFalses = 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_numTrues)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_numFalses)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_numNulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t BooleanColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("BooleanColumnStatsData");
+ xfer += oprot->writeFieldBegin("numTrues", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->numTrues);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("numFalses", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->numFalses);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3);
+ xfer += oprot->writeI64(this->numNulls);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* DoubleColumnStatsData::ascii_fingerprint = "97F958CB0709C3B109A57EEE01946C13";
+const uint8_t DoubleColumnStatsData::binary_fingerprint[16] = {0x97,0xF9,0x58,0xCB,0x07,0x09,0xC3,0xB1,0x09,0xA5,0x7E,0xEE,0x01,0x94,0x6C,0x13};
+
+uint32_t DoubleColumnStatsData::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_DOUBLE) {
+ xfer += iprot->readDouble(this->lowValue);
+ isset_lowValue = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->highValue);
+ 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 DoubleColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("DoubleColumnStatsData");
+ xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_DOUBLE, 1);
+ xfer += oprot->writeDouble(this->lowValue);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_DOUBLE, 2);
+ xfer += oprot->writeDouble(this->highValue);
+ 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;
+}
+
+const char* LongColumnStatsData::ascii_fingerprint = "66C8E6F97F0275919D86FEB536251B17";
+const uint8_t LongColumnStatsData::binary_fingerprint[16] = {0x66,0xC8,0xE6,0xF9,0x7F,0x02,0x75,0x91,0x9D,0x86,0xFE,0xB5,0x36,0x25,0x1B,0x17};
+
+uint32_t LongColumnStatsData::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_I64) {
+ xfer += iprot->readI64(this->lowValue);
+ isset_lowValue = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->highValue);
+ 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 LongColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("LongColumnStatsData");
+ xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->lowValue);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->highValue);
+ 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;
+}
+
+const char* StringColumnStatsData::ascii_fingerprint = "D017B08C3DF12C3AB98788B2E67DAAB3";
+const uint8_t StringColumnStatsData::binary_fingerprint[16] = {0xD0,0x17,0xB0,0x8C,0x3D,0xF1,0x2C,0x3A,0xB9,0x87,0x88,0xB2,0xE6,0x7D,0xAA,0xB3};
+
+uint32_t StringColumnStatsData::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_maxColLen = false;
+ bool isset_avgColLen = 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_I64) {
+ xfer += iprot->readI64(this->maxColLen);
+ isset_maxColLen = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->avgColLen);
+ isset_avgColLen = 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_maxColLen)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_avgColLen)
+ 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 StringColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("StringColumnStatsData");
+ xfer += oprot->writeFieldBegin("maxColLen", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->maxColLen);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("avgColLen", ::apache::thrift::protocol::T_DOUBLE, 2);
+ xfer += oprot->writeDouble(this->avgColLen);
+ 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;
+}
+
+const char* BinaryColumnStatsData::ascii_fingerprint = "22B0CB67183FCDB945892B9974518D06";
+const uint8_t BinaryColumnStatsData::binary_fingerprint[16] = {0x22,0xB0,0xCB,0x67,0x18,0x3F,0xCD,0xB9,0x45,0x89,0x2B,0x99,0x74,0x51,0x8D,0x06};
+
+uint32_t BinaryColumnStatsData::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_maxColLen = false;
+ bool isset_avgColLen = false;
+ bool isset_numNulls = 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_I64) {
+ xfer += iprot->readI64(this->maxColLen);
+ isset_maxColLen = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->avgColLen);
+ isset_avgColLen = 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_maxColLen)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_avgColLen)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_numNulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t BinaryColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("BinaryColumnStatsData");
+ xfer += oprot->writeFieldBegin("maxColLen", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->maxColLen);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("avgColLen", ::apache::thrift::protocol::T_DOUBLE, 2);
+ xfer += oprot->writeDouble(this->avgColLen);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3);
+ xfer += oprot->writeI64(this->numNulls);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+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};
+
+uint32_t ColumnStatisticsData::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;
+
+
+ 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->booleanStats.read(iprot);
+ this->__isset.booleanStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->longStats.read(iprot);
+ this->__isset.longStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->doubleStats.read(iprot);
+ this->__isset.doubleStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->stringStats.read(iprot);
+ this->__isset.stringStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->binaryStats.read(iprot);
+ this->__isset.binaryStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
-uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
+ return xfer;
+}
+
+uint32_t ColumnStatisticsData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ColumnStatisticsData");
+ xfer += oprot->writeFieldBegin("booleanStats", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->booleanStats.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("longStats", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->longStats.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("doubleStats", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->doubleStats.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stringStats", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->stringStats.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("binaryStats", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->binaryStats.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+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};
+
+uint32_t ColumnStatisticsObj::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_colName = false;
+ bool isset_colType = false;
+ bool isset_statsData = 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->readString(this->colName);
+ isset_colName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->colType);
+ isset_colType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->statsData.read(iprot);
+ isset_statsData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_colName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_colType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_statsData)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ColumnStatisticsObj::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ColumnStatisticsObj");
+ xfer += oprot->writeFieldBegin("colName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->colName);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("colType", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->colType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("statsData", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->statsData.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* ColumnStatisticsDesc::ascii_fingerprint = "261759FF6F8FAB53F941453007FE18CB";
+const uint8_t ColumnStatisticsDesc::binary_fingerprint[16] = {0x26,0x17,0x59,0xFF,0x6F,0x8F,0xAB,0x53,0xF9,0x41,0x45,0x30,0x07,0xFE,0x18,0xCB};
+
+uint32_t ColumnStatisticsDesc::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_isTblLevel = false;
+ bool isset_dbName = false;
+ bool isset_tableName = 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_BOOL) {
+ xfer += iprot->readBool(this->isTblLevel);
+ isset_isTblLevel = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbName);
+ isset_dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ isset_tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->partName);
+ this->__isset.partName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->lastAnalyzed);
+ this->__isset.lastAnalyzed = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_isTblLevel)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tableName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ColumnStatisticsDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ColumnStatisticsDesc");
+ xfer += oprot->writeFieldBegin("isTblLevel", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->isTblLevel);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+ if (this->__isset.partName) {
+ xfer += oprot->writeFieldBegin("partName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->partName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.lastAnalyzed) {
+ xfer += oprot->writeFieldBegin("lastAnalyzed", ::apache::thrift::protocol::T_I64, 5);
+ xfer += oprot->writeI64(this->lastAnalyzed);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+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};
+
+uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
std::string fname;
@@ -2283,6 +3044,8 @@ uint32_t Schema::read(::apache::thrift::
using ::apache::thrift::protocol::TProtocolException;
+ bool isset_statsDesc = false;
+ bool isset_statsObj = false;
while (true)
{
@@ -2293,17 +3056,106 @@ uint32_t Schema::read(::apache::thrift::
switch (fid)
{
case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->statsDesc.read(iprot);
+ isset_statsDesc = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
- this->fieldSchemas.clear();
+ this->statsObj.clear();
uint32_t _size173;
::apache::thrift::protocol::TType _etype176;
iprot->readListBegin(_etype176, _size173);
- this->fieldSchemas.resize(_size173);
+ this->statsObj.resize(_size173);
uint32_t _i177;
for (_i177 = 0; _i177 < _size173; ++_i177)
{
- xfer += this->fieldSchemas[_i177].read(iprot);
+ xfer += this->statsObj[_i177].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ isset_statsObj = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_statsDesc)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_statsObj)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ColumnStatistics");
+ xfer += oprot->writeFieldBegin("statsDesc", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->statsDesc.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->statsObj.size()));
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter178;
+ for (_iter178 = this->statsObj.begin(); _iter178 != this->statsObj.end(); ++_iter178)
+ {
+ xfer += (*_iter178).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Schema::ascii_fingerprint = "5CFEE46C975F4E2368D905109B8E3B5B";
+const uint8_t Schema::binary_fingerprint[16] = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B};
+
+uint32_t Schema::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;
+
+
+ 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_LIST) {
+ {
+ this->fieldSchemas.clear();
+ uint32_t _size179;
+ ::apache::thrift::protocol::TType _etype182;
+ iprot->readListBegin(_etype182, _size179);
+ this->fieldSchemas.resize(_size179);
+ uint32_t _i183;
+ for (_i183 = 0; _i183 < _size179; ++_i183)
+ {
+ xfer += this->fieldSchemas[_i183].read(iprot);
}
iprot->readListEnd();
}
@@ -2316,17 +3168,17 @@ uint32_t Schema::read(::apache::thrift::
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size178;
- ::apache::thrift::protocol::TType _ktype179;
- ::apache::thrift::protocol::TType _vtype180;
- iprot->readMapBegin(_ktype179, _vtype180, _size178);
- uint32_t _i182;
- for (_i182 = 0; _i182 < _size178; ++_i182)
+ uint32_t _size184;
+ ::apache::thrift::protocol::TType _ktype185;
+ ::apache::thrift::protocol::TType _vtype186;
+ iprot->readMapBegin(_ktype185, _vtype186, _size184);
+ uint32_t _i188;
+ for (_i188 = 0; _i188 < _size184; ++_i188)
{
- std::string _key183;
- xfer += iprot->readString(_key183);
- std::string& _val184 = this->properties[_key183];
- xfer += iprot->readString(_val184);
+ std::string _key189;
+ xfer += iprot->readString(_key189);
+ std::string& _val190 = this->properties[_key189];
+ xfer += iprot->readString(_val190);
}
iprot->readMapEnd();
}
@@ -2353,10 +3205,10 @@ uint32_t Schema::write(::apache::thrift:
xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fieldSchemas.size()));
- std::vector<FieldSchema> ::const_iterator _iter185;
- for (_iter185 = this->fieldSchemas.begin(); _iter185 != this->fieldSchemas.end(); ++_iter185)
+ std::vector<FieldSchema> ::const_iterator _iter191;
+ for (_iter191 = this->fieldSchemas.begin(); _iter191 != this->fieldSchemas.end(); ++_iter191)
{
- xfer += (*_iter185).write(oprot);
+ xfer += (*_iter191).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -2364,11 +3216,11 @@ uint32_t Schema::write(::apache::thrift:
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter186;
- for (_iter186 = this->properties.begin(); _iter186 != this->properties.end(); ++_iter186)
+ std::map<std::string, std::string> ::const_iterator _iter192;
+ for (_iter192 = this->properties.begin(); _iter192 != this->properties.end(); ++_iter192)
{
- xfer += oprot->writeString(_iter186->first);
- xfer += oprot->writeString(_iter186->second);
+ xfer += oprot->writeString(_iter192->first);
+ xfer += oprot->writeString(_iter192->second);
}
xfer += oprot->writeMapEnd();
}
@@ -2405,17 +3257,17 @@ uint32_t EnvironmentContext::read(::apac
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size187;
- ::apache::thrift::protocol::TType _ktype188;
- ::apache::thrift::protocol::TType _vtype189;
- iprot->readMapBegin(_ktype188, _vtype189, _size187);
- uint32_t _i191;
- for (_i191 = 0; _i191 < _size187; ++_i191)
+ uint32_t _size193;
+ ::apache::thrift::protocol::TType _ktype194;
+ ::apache::thrift::protocol::TType _vtype195;
+ iprot->readMapBegin(_ktype194, _vtype195, _size193);
+ uint32_t _i197;
+ for (_i197 = 0; _i197 < _size193; ++_i197)
{
- std::string _key192;
- xfer += iprot->readString(_key192);
- std::string& _val193 = this->properties[_key192];
- xfer += iprot->readString(_val193);
+ std::string _key198;
+ xfer += iprot->readString(_key198);
+ std::string& _val199 = this->properties[_key198];
+ xfer += iprot->readString(_val199);
}
iprot->readMapEnd();
}
@@ -2442,11 +3294,11 @@ uint32_t EnvironmentContext::write(::apa
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter194;
- for (_iter194 = this->properties.begin(); _iter194 != this->properties.end(); ++_iter194)
+ std::map<std::string, std::string> ::const_iterator _iter200;
+ for (_iter200 = this->properties.begin(); _iter200 != this->properties.end(); ++_iter200)
{
- xfer += oprot->writeString(_iter194->first);
- xfer += oprot->writeString(_iter194->second);
+ xfer += oprot->writeString(_iter200->first);
+ xfer += oprot->writeString(_iter200->second);
}
xfer += oprot->writeMapEnd();
}
@@ -3050,4 +3902,58 @@ uint32_t ConfigValSecurityException::wri
return xfer;
}
+const char* InvalidInputException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t InvalidInputException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t InvalidInputException::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;
+
+
+ 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->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t InvalidInputException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("InvalidInputException");
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
}}} // namespace
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=1406465&r1=1406464&r2=1406465&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 Wed Nov 7 04:55:00 2012
@@ -1308,6 +1308,512 @@ class Index {
};
+
+class BooleanColumnStatsData {
+ public:
+
+ static const char* ascii_fingerprint; // = "EA2D65F1E0BB78760205682082304B41";
+ static const uint8_t binary_fingerprint[16]; // = {0xEA,0x2D,0x65,0xF1,0xE0,0xBB,0x78,0x76,0x02,0x05,0x68,0x20,0x82,0x30,0x4B,0x41};
+
+ BooleanColumnStatsData() : numTrues(0), numFalses(0), numNulls(0) {
+ }
+
+ virtual ~BooleanColumnStatsData() throw() {}
+
+ int64_t numTrues;
+ int64_t numFalses;
+ int64_t numNulls;
+
+ void __set_numTrues(const int64_t val) {
+ numTrues = val;
+ }
+
+ void __set_numFalses(const int64_t val) {
+ numFalses = val;
+ }
+
+ void __set_numNulls(const int64_t val) {
+ numNulls = val;
+ }
+
+ bool operator == (const BooleanColumnStatsData & rhs) const
+ {
+ if (!(numTrues == rhs.numTrues))
+ return false;
+ if (!(numFalses == rhs.numFalses))
+ return false;
+ if (!(numNulls == rhs.numNulls))
+ return false;
+ return true;
+ }
+ bool operator != (const BooleanColumnStatsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const BooleanColumnStatsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class DoubleColumnStatsData {
+ public:
+
+ static const char* ascii_fingerprint; // = "97F958CB0709C3B109A57EEE01946C13";
+ static const uint8_t binary_fingerprint[16]; // = {0x97,0xF9,0x58,0xCB,0x07,0x09,0xC3,0xB1,0x09,0xA5,0x7E,0xEE,0x01,0x94,0x6C,0x13};
+
+ DoubleColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0) {
+ }
+
+ virtual ~DoubleColumnStatsData() throw() {}
+
+ double lowValue;
+ double highValue;
+ int64_t numNulls;
+ int64_t numDVs;
+
+ void __set_lowValue(const double val) {
+ lowValue = val;
+ }
+
+ void __set_highValue(const double val) {
+ highValue = val;
+ }
+
+ void __set_numNulls(const int64_t val) {
+ numNulls = val;
+ }
+
+ void __set_numDVs(const int64_t val) {
+ numDVs = val;
+ }
+
+ bool operator == (const DoubleColumnStatsData & 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 DoubleColumnStatsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DoubleColumnStatsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class LongColumnStatsData {
+ public:
+
+ static const char* ascii_fingerprint; // = "66C8E6F97F0275919D86FEB536251B17";
+ static const uint8_t binary_fingerprint[16]; // = {0x66,0xC8,0xE6,0xF9,0x7F,0x02,0x75,0x91,0x9D,0x86,0xFE,0xB5,0x36,0x25,0x1B,0x17};
+
+ LongColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0) {
+ }
+
+ virtual ~LongColumnStatsData() throw() {}
+
+ int64_t lowValue;
+ int64_t highValue;
+ int64_t numNulls;
+ int64_t numDVs;
+
+ void __set_lowValue(const int64_t val) {
+ lowValue = val;
+ }
+
+ void __set_highValue(const int64_t val) {
+ highValue = val;
+ }
+
+ void __set_numNulls(const int64_t val) {
+ numNulls = val;
+ }
+
+ void __set_numDVs(const int64_t val) {
+ numDVs = val;
+ }
+
+ bool operator == (const LongColumnStatsData & 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 LongColumnStatsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const LongColumnStatsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class StringColumnStatsData {
+ public:
+
+ static const char* ascii_fingerprint; // = "D017B08C3DF12C3AB98788B2E67DAAB3";
+ static const uint8_t binary_fingerprint[16]; // = {0xD0,0x17,0xB0,0x8C,0x3D,0xF1,0x2C,0x3A,0xB9,0x87,0x88,0xB2,0xE6,0x7D,0xAA,0xB3};
+
+ StringColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0), numDVs(0) {
+ }
+
+ virtual ~StringColumnStatsData() throw() {}
+
+ int64_t maxColLen;
+ double avgColLen;
+ int64_t numNulls;
+ int64_t numDVs;
+
+ void __set_maxColLen(const int64_t val) {
+ maxColLen = val;
+ }
+
+ void __set_avgColLen(const double val) {
+ avgColLen = val;
+ }
+
+ void __set_numNulls(const int64_t val) {
+ numNulls = val;
+ }
+
+ void __set_numDVs(const int64_t val) {
+ numDVs = val;
+ }
+
+ bool operator == (const StringColumnStatsData & rhs) const
+ {
+ if (!(maxColLen == rhs.maxColLen))
+ return false;
+ if (!(avgColLen == rhs.avgColLen))
+ return false;
+ if (!(numNulls == rhs.numNulls))
+ return false;
+ if (!(numDVs == rhs.numDVs))
+ return false;
+ return true;
+ }
+ bool operator != (const StringColumnStatsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const StringColumnStatsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class BinaryColumnStatsData {
+ public:
+
+ static const char* ascii_fingerprint; // = "22B0CB67183FCDB945892B9974518D06";
+ static const uint8_t binary_fingerprint[16]; // = {0x22,0xB0,0xCB,0x67,0x18,0x3F,0xCD,0xB9,0x45,0x89,0x2B,0x99,0x74,0x51,0x8D,0x06};
+
+ BinaryColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0) {
+ }
+
+ virtual ~BinaryColumnStatsData() throw() {}
+
+ int64_t maxColLen;
+ double avgColLen;
+ int64_t numNulls;
+
+ void __set_maxColLen(const int64_t val) {
+ maxColLen = val;
+ }
+
+ void __set_avgColLen(const double val) {
+ avgColLen = val;
+ }
+
+ void __set_numNulls(const int64_t val) {
+ numNulls = val;
+ }
+
+ bool operator == (const BinaryColumnStatsData & rhs) const
+ {
+ if (!(maxColLen == rhs.maxColLen))
+ return false;
+ if (!(avgColLen == rhs.avgColLen))
+ return false;
+ if (!(numNulls == rhs.numNulls))
+ return false;
+ return true;
+ }
+ bool operator != (const BinaryColumnStatsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const BinaryColumnStatsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ColumnStatisticsData__isset {
+ _ColumnStatisticsData__isset() : booleanStats(false), longStats(false), doubleStats(false), stringStats(false), binaryStats(false) {}
+ bool booleanStats;
+ bool longStats;
+ bool doubleStats;
+ bool stringStats;
+ bool binaryStats;
+} _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};
+
+ ColumnStatisticsData() {
+ }
+
+ virtual ~ColumnStatisticsData() throw() {}
+
+ BooleanColumnStatsData booleanStats;
+ LongColumnStatsData longStats;
+ DoubleColumnStatsData doubleStats;
+ StringColumnStatsData stringStats;
+ BinaryColumnStatsData binaryStats;
+
+ _ColumnStatisticsData__isset __isset;
+
+ void __set_booleanStats(const BooleanColumnStatsData& val) {
+ booleanStats = val;
+ }
+
+ void __set_longStats(const LongColumnStatsData& val) {
+ longStats = val;
+ }
+
+ void __set_doubleStats(const DoubleColumnStatsData& val) {
+ doubleStats = val;
+ }
+
+ void __set_stringStats(const StringColumnStatsData& val) {
+ stringStats = val;
+ }
+
+ void __set_binaryStats(const BinaryColumnStatsData& val) {
+ binaryStats = val;
+ }
+
+ bool operator == (const ColumnStatisticsData & rhs) const
+ {
+ if (!(booleanStats == rhs.booleanStats))
+ return false;
+ if (!(longStats == rhs.longStats))
+ return false;
+ if (!(doubleStats == rhs.doubleStats))
+ return false;
+ if (!(stringStats == rhs.stringStats))
+ return false;
+ if (!(binaryStats == rhs.binaryStats))
+ return false;
+ return true;
+ }
+ bool operator != (const ColumnStatisticsData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ColumnStatisticsData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+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};
+
+ ColumnStatisticsObj() : colName(""), colType("") {
+ }
+
+ virtual ~ColumnStatisticsObj() throw() {}
+
+ std::string colName;
+ std::string colType;
+ ColumnStatisticsData statsData;
+
+ void __set_colName(const std::string& val) {
+ colName = val;
+ }
+
+ void __set_colType(const std::string& val) {
+ colType = val;
+ }
+
+ void __set_statsData(const ColumnStatisticsData& val) {
+ statsData = val;
+ }
+
+ bool operator == (const ColumnStatisticsObj & rhs) const
+ {
+ if (!(colName == rhs.colName))
+ return false;
+ if (!(colType == rhs.colType))
+ return false;
+ if (!(statsData == rhs.statsData))
+ return false;
+ return true;
+ }
+ bool operator != (const ColumnStatisticsObj &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ColumnStatisticsObj & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ColumnStatisticsDesc__isset {
+ _ColumnStatisticsDesc__isset() : partName(false), lastAnalyzed(false) {}
+ bool partName;
+ bool lastAnalyzed;
+} _ColumnStatisticsDesc__isset;
+
+class ColumnStatisticsDesc {
+ public:
+
+ static const char* ascii_fingerprint; // = "261759FF6F8FAB53F941453007FE18CB";
+ static const uint8_t binary_fingerprint[16]; // = {0x26,0x17,0x59,0xFF,0x6F,0x8F,0xAB,0x53,0xF9,0x41,0x45,0x30,0x07,0xFE,0x18,0xCB};
+
+ ColumnStatisticsDesc() : isTblLevel(0), dbName(""), tableName(""), partName(""), lastAnalyzed(0) {
+ }
+
+ virtual ~ColumnStatisticsDesc() throw() {}
+
+ bool isTblLevel;
+ std::string dbName;
+ std::string tableName;
+ std::string partName;
+ int64_t lastAnalyzed;
+
+ _ColumnStatisticsDesc__isset __isset;
+
+ void __set_isTblLevel(const bool val) {
+ isTblLevel = val;
+ }
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ }
+
+ void __set_tableName(const std::string& val) {
+ tableName = val;
+ }
+
+ void __set_partName(const std::string& val) {
+ partName = val;
+ __isset.partName = true;
+ }
+
+ void __set_lastAnalyzed(const int64_t val) {
+ lastAnalyzed = val;
+ __isset.lastAnalyzed = true;
+ }
+
+ bool operator == (const ColumnStatisticsDesc & rhs) const
+ {
+ if (!(isTblLevel == rhs.isTblLevel))
+ return false;
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tableName == rhs.tableName))
+ return false;
+ if (__isset.partName != rhs.__isset.partName)
+ return false;
+ else if (__isset.partName && !(partName == rhs.partName))
+ return false;
+ if (__isset.lastAnalyzed != rhs.__isset.lastAnalyzed)
+ return false;
+ else if (__isset.lastAnalyzed && !(lastAnalyzed == rhs.lastAnalyzed))
+ return false;
+ return true;
+ }
+ bool operator != (const ColumnStatisticsDesc &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ColumnStatisticsDesc & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+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};
+
+ ColumnStatistics() {
+ }
+
+ virtual ~ColumnStatistics() throw() {}
+
+ ColumnStatisticsDesc statsDesc;
+ std::vector<ColumnStatisticsObj> statsObj;
+
+ void __set_statsDesc(const ColumnStatisticsDesc& val) {
+ statsDesc = val;
+ }
+
+ void __set_statsObj(const std::vector<ColumnStatisticsObj> & val) {
+ statsObj = val;
+ }
+
+ bool operator == (const ColumnStatistics & rhs) const
+ {
+ if (!(statsDesc == rhs.statsDesc))
+ return false;
+ if (!(statsObj == rhs.statsObj))
+ return false;
+ return true;
+ }
+ bool operator != (const ColumnStatistics &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ColumnStatistics & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
typedef struct _Schema__isset {
_Schema__isset() : fieldSchemas(false), properties(false) {}
bool fieldSchemas;
@@ -1849,6 +2355,47 @@ class ConfigValSecurityException : publi
};
+typedef struct _InvalidInputException__isset {
+ _InvalidInputException__isset() : message(false) {}
+ bool message;
+} _InvalidInputException__isset;
+
+class InvalidInputException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ InvalidInputException() : message("") {
+ }
+
+ virtual ~InvalidInputException() throw() {}
+
+ std::string message;
+
+ _InvalidInputException__isset __isset;
+
+ void __set_message(const std::string& val) {
+ message = val;
+ }
+
+ bool operator == (const InvalidInputException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const InvalidInputException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const InvalidInputException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
}}} // namespace
#endif
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BinaryColumnStatsData.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BinaryColumnStatsData.java?rev=1406465&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BinaryColumnStatsData.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BinaryColumnStatsData.java Wed Nov 7 04:55:00 2012
@@ -0,0 +1,512 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+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 BinaryColumnStatsData implements org.apache.thrift.TBase<BinaryColumnStatsData, BinaryColumnStatsData._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("BinaryColumnStatsData");
+
+ private static final org.apache.thrift.protocol.TField MAX_COL_LEN_FIELD_DESC = new org.apache.thrift.protocol.TField("maxColLen", org.apache.thrift.protocol.TType.I64, (short)1);
+ private static final org.apache.thrift.protocol.TField AVG_COL_LEN_FIELD_DESC = new org.apache.thrift.protocol.TField("avgColLen", org.apache.thrift.protocol.TType.DOUBLE, (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 long maxColLen; // required
+ private double avgColLen; // required
+ private long numNulls; // 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 {
+ MAX_COL_LEN((short)1, "maxColLen"),
+ AVG_COL_LEN((short)2, "avgColLen"),
+ NUM_NULLS((short)3, "numNulls");
+
+ 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: // MAX_COL_LEN
+ return MAX_COL_LEN;
+ case 2: // AVG_COL_LEN
+ return AVG_COL_LEN;
+ case 3: // NUM_NULLS
+ return NUM_NULLS;
+ 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 __MAXCOLLEN_ISSET_ID = 0;
+ private static final int __AVGCOLLEN_ISSET_ID = 1;
+ private static final int __NUMNULLS_ISSET_ID = 2;
+ private BitSet __isset_bit_vector = new BitSet(3);
+
+ 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.MAX_COL_LEN, new org.apache.thrift.meta_data.FieldMetaData("maxColLen", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.AVG_COL_LEN, new org.apache.thrift.meta_data.FieldMetaData("avgColLen", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ 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)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(BinaryColumnStatsData.class, metaDataMap);
+ }
+
+ public BinaryColumnStatsData() {
+ }
+
+ public BinaryColumnStatsData(
+ long maxColLen,
+ double avgColLen,
+ long numNulls)
+ {
+ this();
+ this.maxColLen = maxColLen;
+ setMaxColLenIsSet(true);
+ this.avgColLen = avgColLen;
+ setAvgColLenIsSet(true);
+ this.numNulls = numNulls;
+ setNumNullsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public BinaryColumnStatsData(BinaryColumnStatsData other) {
+ __isset_bit_vector.clear();
+ __isset_bit_vector.or(other.__isset_bit_vector);
+ this.maxColLen = other.maxColLen;
+ this.avgColLen = other.avgColLen;
+ this.numNulls = other.numNulls;
+ }
+
+ public BinaryColumnStatsData deepCopy() {
+ return new BinaryColumnStatsData(this);
+ }
+
+ @Override
+ public void clear() {
+ setMaxColLenIsSet(false);
+ this.maxColLen = 0;
+ setAvgColLenIsSet(false);
+ this.avgColLen = 0.0;
+ setNumNullsIsSet(false);
+ this.numNulls = 0;
+ }
+
+ public long getMaxColLen() {
+ return this.maxColLen;
+ }
+
+ public void setMaxColLen(long maxColLen) {
+ this.maxColLen = maxColLen;
+ setMaxColLenIsSet(true);
+ }
+
+ public void unsetMaxColLen() {
+ __isset_bit_vector.clear(__MAXCOLLEN_ISSET_ID);
+ }
+
+ /** Returns true if field maxColLen is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxColLen() {
+ return __isset_bit_vector.get(__MAXCOLLEN_ISSET_ID);
+ }
+
+ public void setMaxColLenIsSet(boolean value) {
+ __isset_bit_vector.set(__MAXCOLLEN_ISSET_ID, value);
+ }
+
+ public double getAvgColLen() {
+ return this.avgColLen;
+ }
+
+ public void setAvgColLen(double avgColLen) {
+ this.avgColLen = avgColLen;
+ setAvgColLenIsSet(true);
+ }
+
+ public void unsetAvgColLen() {
+ __isset_bit_vector.clear(__AVGCOLLEN_ISSET_ID);
+ }
+
+ /** Returns true if field avgColLen is set (has been assigned a value) and false otherwise */
+ public boolean isSetAvgColLen() {
+ return __isset_bit_vector.get(__AVGCOLLEN_ISSET_ID);
+ }
+
+ public void setAvgColLenIsSet(boolean value) {
+ __isset_bit_vector.set(__AVGCOLLEN_ISSET_ID, value);
+ }
+
+ public long getNumNulls() {
+ return this.numNulls;
+ }
+
+ public void setNumNulls(long numNulls) {
+ this.numNulls = numNulls;
+ setNumNullsIsSet(true);
+ }
+
+ public void unsetNumNulls() {
+ __isset_bit_vector.clear(__NUMNULLS_ISSET_ID);
+ }
+
+ /** Returns true if field numNulls is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumNulls() {
+ return __isset_bit_vector.get(__NUMNULLS_ISSET_ID);
+ }
+
+ public void setNumNullsIsSet(boolean value) {
+ __isset_bit_vector.set(__NUMNULLS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case MAX_COL_LEN:
+ if (value == null) {
+ unsetMaxColLen();
+ } else {
+ setMaxColLen((Long)value);
+ }
+ break;
+
+ case AVG_COL_LEN:
+ if (value == null) {
+ unsetAvgColLen();
+ } else {
+ setAvgColLen((Double)value);
+ }
+ break;
+
+ case NUM_NULLS:
+ if (value == null) {
+ unsetNumNulls();
+ } else {
+ setNumNulls((Long)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MAX_COL_LEN:
+ return Long.valueOf(getMaxColLen());
+
+ case AVG_COL_LEN:
+ return Double.valueOf(getAvgColLen());
+
+ case NUM_NULLS:
+ return Long.valueOf(getNumNulls());
+
+ }
+ 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 MAX_COL_LEN:
+ return isSetMaxColLen();
+ case AVG_COL_LEN:
+ return isSetAvgColLen();
+ case NUM_NULLS:
+ return isSetNumNulls();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof BinaryColumnStatsData)
+ return this.equals((BinaryColumnStatsData)that);
+ return false;
+ }
+
+ public boolean equals(BinaryColumnStatsData that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_maxColLen = true;
+ boolean that_present_maxColLen = true;
+ if (this_present_maxColLen || that_present_maxColLen) {
+ if (!(this_present_maxColLen && that_present_maxColLen))
+ return false;
+ if (this.maxColLen != that.maxColLen)
+ return false;
+ }
+
+ boolean this_present_avgColLen = true;
+ boolean that_present_avgColLen = true;
+ if (this_present_avgColLen || that_present_avgColLen) {
+ if (!(this_present_avgColLen && that_present_avgColLen))
+ return false;
+ if (this.avgColLen != that.avgColLen)
+ 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;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_maxColLen = true;
+ builder.append(present_maxColLen);
+ if (present_maxColLen)
+ builder.append(maxColLen);
+
+ boolean present_avgColLen = true;
+ builder.append(present_avgColLen);
+ if (present_avgColLen)
+ builder.append(avgColLen);
+
+ boolean present_numNulls = true;
+ builder.append(present_numNulls);
+ if (present_numNulls)
+ builder.append(numNulls);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(BinaryColumnStatsData other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ BinaryColumnStatsData typedOther = (BinaryColumnStatsData)other;
+
+ lastComparison = Boolean.valueOf(isSetMaxColLen()).compareTo(typedOther.isSetMaxColLen());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxColLen()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxColLen, typedOther.maxColLen);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetAvgColLen()).compareTo(typedOther.isSetAvgColLen());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAvgColLen()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.avgColLen, typedOther.avgColLen);
+ 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;
+ }
+ }
+ 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 {
+ org.apache.thrift.protocol.TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ case 1: // MAX_COL_LEN
+ if (field.type == org.apache.thrift.protocol.TType.I64) {
+ this.maxColLen = iprot.readI64();
+ setMaxColLenIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 2: // AVG_COL_LEN
+ if (field.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ this.avgColLen = iprot.readDouble();
+ setAvgColLenIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 3: // NUM_NULLS
+ if (field.type == org.apache.thrift.protocol.TType.I64) {
+ this.numNulls = iprot.readI64();
+ setNumNullsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(MAX_COL_LEN_FIELD_DESC);
+ oprot.writeI64(this.maxColLen);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(AVG_COL_LEN_FIELD_DESC);
+ oprot.writeDouble(this.avgColLen);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NUM_NULLS_FIELD_DESC);
+ oprot.writeI64(this.numNulls);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("BinaryColumnStatsData(");
+ boolean first = true;
+
+ sb.append("maxColLen:");
+ sb.append(this.maxColLen);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("avgColLen:");
+ sb.append(this.avgColLen);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numNulls:");
+ sb.append(this.numNulls);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetMaxColLen()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'maxColLen' is unset! Struct:" + toString());
+ }
+
+ if (!isSetAvgColLen()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'avgColLen' is unset! Struct:" + toString());
+ }
+
+ if (!isSetNumNulls()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'numNulls' is unset! Struct:" + toString());
+ }
+
+ }
+
+ 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_bit_vector = new BitSet(1);
+ 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);
+ }
+ }
+
+}
+
Propchange: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BinaryColumnStatsData.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BooleanColumnStatsData.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BooleanColumnStatsData.java?rev=1406465&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BooleanColumnStatsData.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BooleanColumnStatsData.java Wed Nov 7 04:55:00 2012
@@ -0,0 +1,512 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+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 BooleanColumnStatsData implements org.apache.thrift.TBase<BooleanColumnStatsData, BooleanColumnStatsData._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("BooleanColumnStatsData");
+
+ private static final org.apache.thrift.protocol.TField NUM_TRUES_FIELD_DESC = new org.apache.thrift.protocol.TField("numTrues", org.apache.thrift.protocol.TType.I64, (short)1);
+ private static final org.apache.thrift.protocol.TField NUM_FALSES_FIELD_DESC = new org.apache.thrift.protocol.TField("numFalses", org.apache.thrift.protocol.TType.I64, (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 long numTrues; // required
+ private long numFalses; // required
+ private long numNulls; // 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 {
+ NUM_TRUES((short)1, "numTrues"),
+ NUM_FALSES((short)2, "numFalses"),
+ NUM_NULLS((short)3, "numNulls");
+
+ 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: // NUM_TRUES
+ return NUM_TRUES;
+ case 2: // NUM_FALSES
+ return NUM_FALSES;
+ case 3: // NUM_NULLS
+ return NUM_NULLS;
+ 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 __NUMTRUES_ISSET_ID = 0;
+ private static final int __NUMFALSES_ISSET_ID = 1;
+ private static final int __NUMNULLS_ISSET_ID = 2;
+ private BitSet __isset_bit_vector = new BitSet(3);
+
+ 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.NUM_TRUES, new org.apache.thrift.meta_data.FieldMetaData("numTrues", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.NUM_FALSES, new org.apache.thrift.meta_data.FieldMetaData("numFalses", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ 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)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(BooleanColumnStatsData.class, metaDataMap);
+ }
+
+ public BooleanColumnStatsData() {
+ }
+
+ public BooleanColumnStatsData(
+ long numTrues,
+ long numFalses,
+ long numNulls)
+ {
+ this();
+ this.numTrues = numTrues;
+ setNumTruesIsSet(true);
+ this.numFalses = numFalses;
+ setNumFalsesIsSet(true);
+ this.numNulls = numNulls;
+ setNumNullsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public BooleanColumnStatsData(BooleanColumnStatsData other) {
+ __isset_bit_vector.clear();
+ __isset_bit_vector.or(other.__isset_bit_vector);
+ this.numTrues = other.numTrues;
+ this.numFalses = other.numFalses;
+ this.numNulls = other.numNulls;
+ }
+
+ public BooleanColumnStatsData deepCopy() {
+ return new BooleanColumnStatsData(this);
+ }
+
+ @Override
+ public void clear() {
+ setNumTruesIsSet(false);
+ this.numTrues = 0;
+ setNumFalsesIsSet(false);
+ this.numFalses = 0;
+ setNumNullsIsSet(false);
+ this.numNulls = 0;
+ }
+
+ public long getNumTrues() {
+ return this.numTrues;
+ }
+
+ public void setNumTrues(long numTrues) {
+ this.numTrues = numTrues;
+ setNumTruesIsSet(true);
+ }
+
+ public void unsetNumTrues() {
+ __isset_bit_vector.clear(__NUMTRUES_ISSET_ID);
+ }
+
+ /** Returns true if field numTrues is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumTrues() {
+ return __isset_bit_vector.get(__NUMTRUES_ISSET_ID);
+ }
+
+ public void setNumTruesIsSet(boolean value) {
+ __isset_bit_vector.set(__NUMTRUES_ISSET_ID, value);
+ }
+
+ public long getNumFalses() {
+ return this.numFalses;
+ }
+
+ public void setNumFalses(long numFalses) {
+ this.numFalses = numFalses;
+ setNumFalsesIsSet(true);
+ }
+
+ public void unsetNumFalses() {
+ __isset_bit_vector.clear(__NUMFALSES_ISSET_ID);
+ }
+
+ /** Returns true if field numFalses is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumFalses() {
+ return __isset_bit_vector.get(__NUMFALSES_ISSET_ID);
+ }
+
+ public void setNumFalsesIsSet(boolean value) {
+ __isset_bit_vector.set(__NUMFALSES_ISSET_ID, value);
+ }
+
+ public long getNumNulls() {
+ return this.numNulls;
+ }
+
+ public void setNumNulls(long numNulls) {
+ this.numNulls = numNulls;
+ setNumNullsIsSet(true);
+ }
+
+ public void unsetNumNulls() {
+ __isset_bit_vector.clear(__NUMNULLS_ISSET_ID);
+ }
+
+ /** Returns true if field numNulls is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumNulls() {
+ return __isset_bit_vector.get(__NUMNULLS_ISSET_ID);
+ }
+
+ public void setNumNullsIsSet(boolean value) {
+ __isset_bit_vector.set(__NUMNULLS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case NUM_TRUES:
+ if (value == null) {
+ unsetNumTrues();
+ } else {
+ setNumTrues((Long)value);
+ }
+ break;
+
+ case NUM_FALSES:
+ if (value == null) {
+ unsetNumFalses();
+ } else {
+ setNumFalses((Long)value);
+ }
+ break;
+
+ case NUM_NULLS:
+ if (value == null) {
+ unsetNumNulls();
+ } else {
+ setNumNulls((Long)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NUM_TRUES:
+ return Long.valueOf(getNumTrues());
+
+ case NUM_FALSES:
+ return Long.valueOf(getNumFalses());
+
+ case NUM_NULLS:
+ return Long.valueOf(getNumNulls());
+
+ }
+ 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 NUM_TRUES:
+ return isSetNumTrues();
+ case NUM_FALSES:
+ return isSetNumFalses();
+ case NUM_NULLS:
+ return isSetNumNulls();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof BooleanColumnStatsData)
+ return this.equals((BooleanColumnStatsData)that);
+ return false;
+ }
+
+ public boolean equals(BooleanColumnStatsData that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_numTrues = true;
+ boolean that_present_numTrues = true;
+ if (this_present_numTrues || that_present_numTrues) {
+ if (!(this_present_numTrues && that_present_numTrues))
+ return false;
+ if (this.numTrues != that.numTrues)
+ return false;
+ }
+
+ boolean this_present_numFalses = true;
+ boolean that_present_numFalses = true;
+ if (this_present_numFalses || that_present_numFalses) {
+ if (!(this_present_numFalses && that_present_numFalses))
+ return false;
+ if (this.numFalses != that.numFalses)
+ 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;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_numTrues = true;
+ builder.append(present_numTrues);
+ if (present_numTrues)
+ builder.append(numTrues);
+
+ boolean present_numFalses = true;
+ builder.append(present_numFalses);
+ if (present_numFalses)
+ builder.append(numFalses);
+
+ boolean present_numNulls = true;
+ builder.append(present_numNulls);
+ if (present_numNulls)
+ builder.append(numNulls);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(BooleanColumnStatsData other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ BooleanColumnStatsData typedOther = (BooleanColumnStatsData)other;
+
+ lastComparison = Boolean.valueOf(isSetNumTrues()).compareTo(typedOther.isSetNumTrues());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumTrues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numTrues, typedOther.numTrues);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetNumFalses()).compareTo(typedOther.isSetNumFalses());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumFalses()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numFalses, typedOther.numFalses);
+ 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;
+ }
+ }
+ 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 {
+ org.apache.thrift.protocol.TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ case 1: // NUM_TRUES
+ if (field.type == org.apache.thrift.protocol.TType.I64) {
+ this.numTrues = iprot.readI64();
+ setNumTruesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 2: // NUM_FALSES
+ if (field.type == org.apache.thrift.protocol.TType.I64) {
+ this.numFalses = iprot.readI64();
+ setNumFalsesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 3: // NUM_NULLS
+ if (field.type == org.apache.thrift.protocol.TType.I64) {
+ this.numNulls = iprot.readI64();
+ setNumNullsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(NUM_TRUES_FIELD_DESC);
+ oprot.writeI64(this.numTrues);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NUM_FALSES_FIELD_DESC);
+ oprot.writeI64(this.numFalses);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NUM_NULLS_FIELD_DESC);
+ oprot.writeI64(this.numNulls);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("BooleanColumnStatsData(");
+ boolean first = true;
+
+ sb.append("numTrues:");
+ sb.append(this.numTrues);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numFalses:");
+ sb.append(this.numFalses);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numNulls:");
+ sb.append(this.numNulls);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetNumTrues()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'numTrues' is unset! Struct:" + toString());
+ }
+
+ if (!isSetNumFalses()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'numFalses' is unset! Struct:" + toString());
+ }
+
+ if (!isSetNumNulls()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'numNulls' is unset! Struct:" + toString());
+ }
+
+ }
+
+ 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_bit_vector = new BitSet(1);
+ 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);
+ }
+ }
+
+}
+
Propchange: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/BooleanColumnStatsData.java
------------------------------------------------------------------------------
svn:eol-style = native