You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by gu...@apache.org on 2014/09/05 21:15:48 UTC
svn commit: r1622763 [5/17] - in /hive/branches/tez: ./
ant/src/org/apache/hadoop/hive/ant/
hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/
hcatalog/streaming/src/test/org/apache/hive/hcatalog/streaming/
itests/hive-unit/ itests/hive-un...
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1622763&r1=1622762&r2=1622763&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Fri Sep 5 19:15:44 2014
@@ -3306,6 +3306,471 @@ void swap(Partition &a, Partition &b) {
swap(a.__isset, b.__isset);
}
+const char* PartitionWithoutSD::ascii_fingerprint = "D79FA44499888D0E50B5625E0C536DEA";
+const uint8_t PartitionWithoutSD::binary_fingerprint[16] = {0xD7,0x9F,0xA4,0x44,0x99,0x88,0x8D,0x0E,0x50,0xB5,0x62,0x5E,0x0C,0x53,0x6D,0xEA};
+
+uint32_t PartitionWithoutSD::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->values.clear();
+ uint32_t _size185;
+ ::apache::thrift::protocol::TType _etype188;
+ xfer += iprot->readListBegin(_etype188, _size185);
+ this->values.resize(_size185);
+ uint32_t _i189;
+ for (_i189 = 0; _i189 < _size185; ++_i189)
+ {
+ xfer += iprot->readString(this->values[_i189]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->createTime);
+ this->__isset.createTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->lastAccessTime);
+ this->__isset.lastAccessTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->relativePath);
+ this->__isset.relativePath = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->parameters.clear();
+ uint32_t _size190;
+ ::apache::thrift::protocol::TType _ktype191;
+ ::apache::thrift::protocol::TType _vtype192;
+ xfer += iprot->readMapBegin(_ktype191, _vtype192, _size190);
+ uint32_t _i194;
+ for (_i194 = 0; _i194 < _size190; ++_i194)
+ {
+ std::string _key195;
+ xfer += iprot->readString(_key195);
+ std::string& _val196 = this->parameters[_key195];
+ xfer += iprot->readString(_val196);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.parameters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->privileges.read(iprot);
+ this->__isset.privileges = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionWithoutSD");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
+ std::vector<std::string> ::const_iterator _iter197;
+ for (_iter197 = this->values.begin(); _iter197 != this->values.end(); ++_iter197)
+ {
+ xfer += oprot->writeString((*_iter197));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->createTime);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("lastAccessTime", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->lastAccessTime);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("relativePath", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->relativePath);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
+ std::map<std::string, std::string> ::const_iterator _iter198;
+ for (_iter198 = this->parameters.begin(); _iter198 != this->parameters.end(); ++_iter198)
+ {
+ xfer += oprot->writeString(_iter198->first);
+ xfer += oprot->writeString(_iter198->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.privileges) {
+ xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->privileges.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+ swap(a.createTime, b.createTime);
+ swap(a.lastAccessTime, b.lastAccessTime);
+ swap(a.relativePath, b.relativePath);
+ swap(a.parameters, b.parameters);
+ swap(a.privileges, b.privileges);
+ swap(a.__isset, b.__isset);
+}
+
+const char* PartitionSpecWithSharedSD::ascii_fingerprint = "7BEE9305B42DCD083FF06BEE6DDC61CF";
+const uint8_t PartitionSpecWithSharedSD::binary_fingerprint[16] = {0x7B,0xEE,0x93,0x05,0xB4,0x2D,0xCD,0x08,0x3F,0xF0,0x6B,0xEE,0x6D,0xDC,0x61,0xCF};
+
+uint32_t PartitionSpecWithSharedSD::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->partitions.clear();
+ uint32_t _size199;
+ ::apache::thrift::protocol::TType _etype202;
+ xfer += iprot->readListBegin(_etype202, _size199);
+ this->partitions.resize(_size199);
+ uint32_t _i203;
+ for (_i203 = 0; _i203 < _size199; ++_i203)
+ {
+ xfer += this->partitions[_i203].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.partitions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sd.read(iprot);
+ this->__isset.sd = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionSpecWithSharedSD");
+
+ xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
+ std::vector<PartitionWithoutSD> ::const_iterator _iter204;
+ for (_iter204 = this->partitions.begin(); _iter204 != this->partitions.end(); ++_iter204)
+ {
+ xfer += (*_iter204).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("sd", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->sd.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) {
+ using ::std::swap;
+ swap(a.partitions, b.partitions);
+ swap(a.sd, b.sd);
+ swap(a.__isset, b.__isset);
+}
+
+const char* PartitionListComposingSpec::ascii_fingerprint = "A048235CB9A257C8A74E3691BEFE0674";
+const uint8_t PartitionListComposingSpec::binary_fingerprint[16] = {0xA0,0x48,0x23,0x5C,0xB9,0xA2,0x57,0xC8,0xA7,0x4E,0x36,0x91,0xBE,0xFE,0x06,0x74};
+
+uint32_t PartitionListComposingSpec::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->partitions.clear();
+ uint32_t _size205;
+ ::apache::thrift::protocol::TType _etype208;
+ xfer += iprot->readListBegin(_etype208, _size205);
+ this->partitions.resize(_size205);
+ uint32_t _i209;
+ for (_i209 = 0; _i209 < _size205; ++_i209)
+ {
+ xfer += this->partitions[_i209].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.partitions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionListComposingSpec");
+
+ xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
+ std::vector<Partition> ::const_iterator _iter210;
+ for (_iter210 = this->partitions.begin(); _iter210 != this->partitions.end(); ++_iter210)
+ {
+ xfer += (*_iter210).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) {
+ using ::std::swap;
+ swap(a.partitions, b.partitions);
+ swap(a.__isset, b.__isset);
+}
+
+const char* PartitionSpec::ascii_fingerprint = "C3F548C24D072CF6422F25096143E3E8";
+const uint8_t PartitionSpec::binary_fingerprint[16] = {0xC3,0xF5,0x48,0xC2,0x4D,0x07,0x2C,0xF6,0x42,0x2F,0x25,0x09,0x61,0x43,0xE3,0xE8};
+
+uint32_t PartitionSpec::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->dbName);
+ this->__isset.dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ this->__isset.tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->rootPath);
+ this->__isset.rootPath = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sharedSDPartitionSpec.read(iprot);
+ this->__isset.sharedSDPartitionSpec = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->partitionList.read(iprot);
+ this->__isset.partitionList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t PartitionSpec::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionSpec");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("rootPath", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->rootPath);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.sharedSDPartitionSpec) {
+ xfer += oprot->writeFieldBegin("sharedSDPartitionSpec", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->sharedSDPartitionSpec.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.partitionList) {
+ xfer += oprot->writeFieldBegin("partitionList", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->partitionList.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionSpec &a, PartitionSpec &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tableName, b.tableName);
+ swap(a.rootPath, b.rootPath);
+ swap(a.sharedSDPartitionSpec, b.sharedSDPartitionSpec);
+ swap(a.partitionList, b.partitionList);
+ swap(a.__isset, b.__isset);
+}
+
const char* Index::ascii_fingerprint = "09EEF655216AC81802850988D6C470A6";
const uint8_t Index::binary_fingerprint[16] = {0x09,0xEE,0xF6,0x55,0x21,0x6A,0xC8,0x18,0x02,0x85,0x09,0x88,0xD6,0xC4,0x70,0xA6};
@@ -3397,17 +3862,17 @@ uint32_t Index::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size185;
- ::apache::thrift::protocol::TType _ktype186;
- ::apache::thrift::protocol::TType _vtype187;
- xfer += iprot->readMapBegin(_ktype186, _vtype187, _size185);
- uint32_t _i189;
- for (_i189 = 0; _i189 < _size185; ++_i189)
+ uint32_t _size211;
+ ::apache::thrift::protocol::TType _ktype212;
+ ::apache::thrift::protocol::TType _vtype213;
+ xfer += iprot->readMapBegin(_ktype212, _vtype213, _size211);
+ uint32_t _i215;
+ for (_i215 = 0; _i215 < _size211; ++_i215)
{
- std::string _key190;
- xfer += iprot->readString(_key190);
- std::string& _val191 = this->parameters[_key190];
- xfer += iprot->readString(_val191);
+ std::string _key216;
+ xfer += iprot->readString(_key216);
+ std::string& _val217 = this->parameters[_key216];
+ xfer += iprot->readString(_val217);
}
xfer += iprot->readMapEnd();
}
@@ -3475,11 +3940,11 @@ uint32_t Index::write(::apache::thrift::
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter192;
- for (_iter192 = this->parameters.begin(); _iter192 != this->parameters.end(); ++_iter192)
+ std::map<std::string, std::string> ::const_iterator _iter218;
+ for (_iter218 = this->parameters.begin(); _iter218 != this->parameters.end(); ++_iter218)
{
- xfer += oprot->writeString(_iter192->first);
- xfer += oprot->writeString(_iter192->second);
+ xfer += oprot->writeString(_iter218->first);
+ xfer += oprot->writeString(_iter218->second);
}
xfer += oprot->writeMapEnd();
}
@@ -4605,14 +5070,14 @@ uint32_t ColumnStatistics::read(::apache
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->statsObj.clear();
- uint32_t _size193;
- ::apache::thrift::protocol::TType _etype196;
- xfer += iprot->readListBegin(_etype196, _size193);
- this->statsObj.resize(_size193);
- uint32_t _i197;
- for (_i197 = 0; _i197 < _size193; ++_i197)
+ uint32_t _size219;
+ ::apache::thrift::protocol::TType _etype222;
+ xfer += iprot->readListBegin(_etype222, _size219);
+ this->statsObj.resize(_size219);
+ uint32_t _i223;
+ for (_i223 = 0; _i223 < _size219; ++_i223)
{
- xfer += this->statsObj[_i197].read(iprot);
+ xfer += this->statsObj[_i223].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4648,10 +5113,10 @@ uint32_t ColumnStatistics::write(::apach
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 _iter198;
- for (_iter198 = this->statsObj.begin(); _iter198 != this->statsObj.end(); ++_iter198)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter224;
+ for (_iter224 = this->statsObj.begin(); _iter224 != this->statsObj.end(); ++_iter224)
{
- xfer += (*_iter198).write(oprot);
+ xfer += (*_iter224).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4697,14 +5162,14 @@ uint32_t AggrStats::read(::apache::thrif
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size199;
- ::apache::thrift::protocol::TType _etype202;
- xfer += iprot->readListBegin(_etype202, _size199);
- this->colStats.resize(_size199);
- uint32_t _i203;
- for (_i203 = 0; _i203 < _size199; ++_i203)
+ uint32_t _size225;
+ ::apache::thrift::protocol::TType _etype228;
+ xfer += iprot->readListBegin(_etype228, _size225);
+ this->colStats.resize(_size225);
+ uint32_t _i229;
+ for (_i229 = 0; _i229 < _size225; ++_i229)
{
- xfer += this->colStats[_i203].read(iprot);
+ xfer += this->colStats[_i229].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4744,10 +5209,10 @@ uint32_t AggrStats::write(::apache::thri
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter204;
- for (_iter204 = this->colStats.begin(); _iter204 != this->colStats.end(); ++_iter204)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter230;
+ for (_iter230 = this->colStats.begin(); _iter230 != this->colStats.end(); ++_iter230)
{
- xfer += (*_iter204).write(oprot);
+ xfer += (*_iter230).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4796,14 +5261,14 @@ uint32_t SetPartitionsStatsRequest::read
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size205;
- ::apache::thrift::protocol::TType _etype208;
- xfer += iprot->readListBegin(_etype208, _size205);
- this->colStats.resize(_size205);
- uint32_t _i209;
- for (_i209 = 0; _i209 < _size205; ++_i209)
+ uint32_t _size231;
+ ::apache::thrift::protocol::TType _etype234;
+ xfer += iprot->readListBegin(_etype234, _size231);
+ this->colStats.resize(_size231);
+ uint32_t _i235;
+ for (_i235 = 0; _i235 < _size231; ++_i235)
{
- xfer += this->colStats[_i209].read(iprot);
+ xfer += this->colStats[_i235].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4833,10 +5298,10 @@ uint32_t SetPartitionsStatsRequest::writ
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatistics> ::const_iterator _iter210;
- for (_iter210 = this->colStats.begin(); _iter210 != this->colStats.end(); ++_iter210)
+ std::vector<ColumnStatistics> ::const_iterator _iter236;
+ for (_iter236 = this->colStats.begin(); _iter236 != this->colStats.end(); ++_iter236)
{
- xfer += (*_iter210).write(oprot);
+ xfer += (*_iter236).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4879,14 +5344,14 @@ uint32_t Schema::read(::apache::thrift::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fieldSchemas.clear();
- uint32_t _size211;
- ::apache::thrift::protocol::TType _etype214;
- xfer += iprot->readListBegin(_etype214, _size211);
- this->fieldSchemas.resize(_size211);
- uint32_t _i215;
- for (_i215 = 0; _i215 < _size211; ++_i215)
+ uint32_t _size237;
+ ::apache::thrift::protocol::TType _etype240;
+ xfer += iprot->readListBegin(_etype240, _size237);
+ this->fieldSchemas.resize(_size237);
+ uint32_t _i241;
+ for (_i241 = 0; _i241 < _size237; ++_i241)
{
- xfer += this->fieldSchemas[_i215].read(iprot);
+ xfer += this->fieldSchemas[_i241].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4899,17 +5364,17 @@ uint32_t Schema::read(::apache::thrift::
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size216;
- ::apache::thrift::protocol::TType _ktype217;
- ::apache::thrift::protocol::TType _vtype218;
- xfer += iprot->readMapBegin(_ktype217, _vtype218, _size216);
- uint32_t _i220;
- for (_i220 = 0; _i220 < _size216; ++_i220)
+ uint32_t _size242;
+ ::apache::thrift::protocol::TType _ktype243;
+ ::apache::thrift::protocol::TType _vtype244;
+ xfer += iprot->readMapBegin(_ktype243, _vtype244, _size242);
+ uint32_t _i246;
+ for (_i246 = 0; _i246 < _size242; ++_i246)
{
- std::string _key221;
- xfer += iprot->readString(_key221);
- std::string& _val222 = this->properties[_key221];
- xfer += iprot->readString(_val222);
+ std::string _key247;
+ xfer += iprot->readString(_key247);
+ std::string& _val248 = this->properties[_key247];
+ xfer += iprot->readString(_val248);
}
xfer += iprot->readMapEnd();
}
@@ -4937,10 +5402,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 _iter223;
- for (_iter223 = this->fieldSchemas.begin(); _iter223 != this->fieldSchemas.end(); ++_iter223)
+ std::vector<FieldSchema> ::const_iterator _iter249;
+ for (_iter249 = this->fieldSchemas.begin(); _iter249 != this->fieldSchemas.end(); ++_iter249)
{
- xfer += (*_iter223).write(oprot);
+ xfer += (*_iter249).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4949,11 +5414,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 _iter224;
- for (_iter224 = this->properties.begin(); _iter224 != this->properties.end(); ++_iter224)
+ std::map<std::string, std::string> ::const_iterator _iter250;
+ for (_iter250 = this->properties.begin(); _iter250 != this->properties.end(); ++_iter250)
{
- xfer += oprot->writeString(_iter224->first);
- xfer += oprot->writeString(_iter224->second);
+ xfer += oprot->writeString(_iter250->first);
+ xfer += oprot->writeString(_iter250->second);
}
xfer += oprot->writeMapEnd();
}
@@ -4998,17 +5463,17 @@ uint32_t EnvironmentContext::read(::apac
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size225;
- ::apache::thrift::protocol::TType _ktype226;
- ::apache::thrift::protocol::TType _vtype227;
- xfer += iprot->readMapBegin(_ktype226, _vtype227, _size225);
- uint32_t _i229;
- for (_i229 = 0; _i229 < _size225; ++_i229)
+ uint32_t _size251;
+ ::apache::thrift::protocol::TType _ktype252;
+ ::apache::thrift::protocol::TType _vtype253;
+ xfer += iprot->readMapBegin(_ktype252, _vtype253, _size251);
+ uint32_t _i255;
+ for (_i255 = 0; _i255 < _size251; ++_i255)
{
- std::string _key230;
- xfer += iprot->readString(_key230);
- std::string& _val231 = this->properties[_key230];
- xfer += iprot->readString(_val231);
+ std::string _key256;
+ xfer += iprot->readString(_key256);
+ std::string& _val257 = this->properties[_key256];
+ xfer += iprot->readString(_val257);
}
xfer += iprot->readMapEnd();
}
@@ -5036,11 +5501,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 _iter232;
- for (_iter232 = this->properties.begin(); _iter232 != this->properties.end(); ++_iter232)
+ std::map<std::string, std::string> ::const_iterator _iter258;
+ for (_iter258 = this->properties.begin(); _iter258 != this->properties.end(); ++_iter258)
{
- xfer += oprot->writeString(_iter232->first);
- xfer += oprot->writeString(_iter232->second);
+ xfer += oprot->writeString(_iter258->first);
+ xfer += oprot->writeString(_iter258->second);
}
xfer += oprot->writeMapEnd();
}
@@ -5086,14 +5551,14 @@ uint32_t PartitionsByExprResult::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size233;
- ::apache::thrift::protocol::TType _etype236;
- xfer += iprot->readListBegin(_etype236, _size233);
- this->partitions.resize(_size233);
- uint32_t _i237;
- for (_i237 = 0; _i237 < _size233; ++_i237)
+ uint32_t _size259;
+ ::apache::thrift::protocol::TType _etype262;
+ xfer += iprot->readListBegin(_etype262, _size259);
+ this->partitions.resize(_size259);
+ uint32_t _i263;
+ for (_i263 = 0; _i263 < _size259; ++_i263)
{
- xfer += this->partitions[_i237].read(iprot);
+ xfer += this->partitions[_i263].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5133,10 +5598,10 @@ uint32_t PartitionsByExprResult::write(:
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter238;
- for (_iter238 = this->partitions.begin(); _iter238 != this->partitions.end(); ++_iter238)
+ std::vector<Partition> ::const_iterator _iter264;
+ for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264)
{
- xfer += (*_iter238).write(oprot);
+ xfer += (*_iter264).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5310,14 +5775,14 @@ uint32_t TableStatsResult::read(::apache
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tableStats.clear();
- uint32_t _size239;
- ::apache::thrift::protocol::TType _etype242;
- xfer += iprot->readListBegin(_etype242, _size239);
- this->tableStats.resize(_size239);
- uint32_t _i243;
- for (_i243 = 0; _i243 < _size239; ++_i243)
+ uint32_t _size265;
+ ::apache::thrift::protocol::TType _etype268;
+ xfer += iprot->readListBegin(_etype268, _size265);
+ this->tableStats.resize(_size265);
+ uint32_t _i269;
+ for (_i269 = 0; _i269 < _size265; ++_i269)
{
- xfer += this->tableStats[_i243].read(iprot);
+ xfer += this->tableStats[_i269].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5347,10 +5812,10 @@ uint32_t TableStatsResult::write(::apach
xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tableStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter244;
- for (_iter244 = this->tableStats.begin(); _iter244 != this->tableStats.end(); ++_iter244)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter270;
+ for (_iter270 = this->tableStats.begin(); _iter270 != this->tableStats.end(); ++_iter270)
{
- xfer += (*_iter244).write(oprot);
+ xfer += (*_iter270).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5394,26 +5859,26 @@ uint32_t PartitionsStatsResult::read(::a
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->partStats.clear();
- uint32_t _size245;
- ::apache::thrift::protocol::TType _ktype246;
- ::apache::thrift::protocol::TType _vtype247;
- xfer += iprot->readMapBegin(_ktype246, _vtype247, _size245);
- uint32_t _i249;
- for (_i249 = 0; _i249 < _size245; ++_i249)
+ uint32_t _size271;
+ ::apache::thrift::protocol::TType _ktype272;
+ ::apache::thrift::protocol::TType _vtype273;
+ xfer += iprot->readMapBegin(_ktype272, _vtype273, _size271);
+ uint32_t _i275;
+ for (_i275 = 0; _i275 < _size271; ++_i275)
{
- std::string _key250;
- xfer += iprot->readString(_key250);
- std::vector<ColumnStatisticsObj> & _val251 = this->partStats[_key250];
+ std::string _key276;
+ xfer += iprot->readString(_key276);
+ std::vector<ColumnStatisticsObj> & _val277 = this->partStats[_key276];
{
- _val251.clear();
- uint32_t _size252;
- ::apache::thrift::protocol::TType _etype255;
- xfer += iprot->readListBegin(_etype255, _size252);
- _val251.resize(_size252);
- uint32_t _i256;
- for (_i256 = 0; _i256 < _size252; ++_i256)
+ _val277.clear();
+ uint32_t _size278;
+ ::apache::thrift::protocol::TType _etype281;
+ xfer += iprot->readListBegin(_etype281, _size278);
+ _val277.resize(_size278);
+ uint32_t _i282;
+ for (_i282 = 0; _i282 < _size278; ++_i282)
{
- xfer += _val251[_i256].read(iprot);
+ xfer += _val277[_i282].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5446,16 +5911,16 @@ uint32_t PartitionsStatsResult::write(::
xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->partStats.size()));
- std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter257;
- for (_iter257 = this->partStats.begin(); _iter257 != this->partStats.end(); ++_iter257)
+ std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter283;
+ for (_iter283 = this->partStats.begin(); _iter283 != this->partStats.end(); ++_iter283)
{
- xfer += oprot->writeString(_iter257->first);
+ xfer += oprot->writeString(_iter283->first);
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter257->second.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter258;
- for (_iter258 = _iter257->second.begin(); _iter258 != _iter257->second.end(); ++_iter258)
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter283->second.size()));
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter284;
+ for (_iter284 = _iter283->second.begin(); _iter284 != _iter283->second.end(); ++_iter284)
{
- xfer += (*_iter258).write(oprot);
+ xfer += (*_iter284).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5520,14 +5985,14 @@ uint32_t TableStatsRequest::read(::apach
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- uint32_t _size259;
- ::apache::thrift::protocol::TType _etype262;
- xfer += iprot->readListBegin(_etype262, _size259);
- this->colNames.resize(_size259);
- uint32_t _i263;
- for (_i263 = 0; _i263 < _size259; ++_i263)
+ uint32_t _size285;
+ ::apache::thrift::protocol::TType _etype288;
+ xfer += iprot->readListBegin(_etype288, _size285);
+ this->colNames.resize(_size285);
+ uint32_t _i289;
+ for (_i289 = 0; _i289 < _size285; ++_i289)
{
- xfer += iprot->readString(this->colNames[_i263]);
+ xfer += iprot->readString(this->colNames[_i289]);
}
xfer += iprot->readListEnd();
}
@@ -5569,10 +6034,10 @@ uint32_t TableStatsRequest::write(::apac
xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size()));
- std::vector<std::string> ::const_iterator _iter264;
- for (_iter264 = this->colNames.begin(); _iter264 != this->colNames.end(); ++_iter264)
+ std::vector<std::string> ::const_iterator _iter290;
+ for (_iter290 = this->colNames.begin(); _iter290 != this->colNames.end(); ++_iter290)
{
- xfer += oprot->writeString((*_iter264));
+ xfer += oprot->writeString((*_iter290));
}
xfer += oprot->writeListEnd();
}
@@ -5637,14 +6102,14 @@ uint32_t PartitionsStatsRequest::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- uint32_t _size265;
- ::apache::thrift::protocol::TType _etype268;
- xfer += iprot->readListBegin(_etype268, _size265);
- this->colNames.resize(_size265);
- uint32_t _i269;
- for (_i269 = 0; _i269 < _size265; ++_i269)
+ uint32_t _size291;
+ ::apache::thrift::protocol::TType _etype294;
+ xfer += iprot->readListBegin(_etype294, _size291);
+ this->colNames.resize(_size291);
+ uint32_t _i295;
+ for (_i295 = 0; _i295 < _size291; ++_i295)
{
- xfer += iprot->readString(this->colNames[_i269]);
+ xfer += iprot->readString(this->colNames[_i295]);
}
xfer += iprot->readListEnd();
}
@@ -5657,14 +6122,14 @@ uint32_t PartitionsStatsRequest::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- uint32_t _size270;
- ::apache::thrift::protocol::TType _etype273;
- xfer += iprot->readListBegin(_etype273, _size270);
- this->partNames.resize(_size270);
- uint32_t _i274;
- for (_i274 = 0; _i274 < _size270; ++_i274)
+ uint32_t _size296;
+ ::apache::thrift::protocol::TType _etype299;
+ xfer += iprot->readListBegin(_etype299, _size296);
+ this->partNames.resize(_size296);
+ uint32_t _i300;
+ for (_i300 = 0; _i300 < _size296; ++_i300)
{
- xfer += iprot->readString(this->partNames[_i274]);
+ xfer += iprot->readString(this->partNames[_i300]);
}
xfer += iprot->readListEnd();
}
@@ -5708,10 +6173,10 @@ uint32_t PartitionsStatsRequest::write(:
xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size()));
- std::vector<std::string> ::const_iterator _iter275;
- for (_iter275 = this->colNames.begin(); _iter275 != this->colNames.end(); ++_iter275)
+ std::vector<std::string> ::const_iterator _iter301;
+ for (_iter301 = this->colNames.begin(); _iter301 != this->colNames.end(); ++_iter301)
{
- xfer += oprot->writeString((*_iter275));
+ xfer += oprot->writeString((*_iter301));
}
xfer += oprot->writeListEnd();
}
@@ -5720,10 +6185,10 @@ uint32_t PartitionsStatsRequest::write(:
xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size()));
- std::vector<std::string> ::const_iterator _iter276;
- for (_iter276 = this->partNames.begin(); _iter276 != this->partNames.end(); ++_iter276)
+ std::vector<std::string> ::const_iterator _iter302;
+ for (_iter302 = this->partNames.begin(); _iter302 != this->partNames.end(); ++_iter302)
{
- xfer += oprot->writeString((*_iter276));
+ xfer += oprot->writeString((*_iter302));
}
xfer += oprot->writeListEnd();
}
@@ -5769,14 +6234,14 @@ uint32_t AddPartitionsResult::read(::apa
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size277;
- ::apache::thrift::protocol::TType _etype280;
- xfer += iprot->readListBegin(_etype280, _size277);
- this->partitions.resize(_size277);
- uint32_t _i281;
- for (_i281 = 0; _i281 < _size277; ++_i281)
+ uint32_t _size303;
+ ::apache::thrift::protocol::TType _etype306;
+ xfer += iprot->readListBegin(_etype306, _size303);
+ this->partitions.resize(_size303);
+ uint32_t _i307;
+ for (_i307 = 0; _i307 < _size303; ++_i307)
{
- xfer += this->partitions[_i281].read(iprot);
+ xfer += this->partitions[_i307].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5805,10 +6270,10 @@ uint32_t AddPartitionsResult::write(::ap
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter282;
- for (_iter282 = this->partitions.begin(); _iter282 != this->partitions.end(); ++_iter282)
+ std::vector<Partition> ::const_iterator _iter308;
+ for (_iter308 = this->partitions.begin(); _iter308 != this->partitions.end(); ++_iter308)
{
- xfer += (*_iter282).write(oprot);
+ xfer += (*_iter308).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5872,14 +6337,14 @@ uint32_t AddPartitionsRequest::read(::ap
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->parts.clear();
- uint32_t _size283;
- ::apache::thrift::protocol::TType _etype286;
- xfer += iprot->readListBegin(_etype286, _size283);
- this->parts.resize(_size283);
- uint32_t _i287;
- for (_i287 = 0; _i287 < _size283; ++_i287)
+ uint32_t _size309;
+ ::apache::thrift::protocol::TType _etype312;
+ xfer += iprot->readListBegin(_etype312, _size309);
+ this->parts.resize(_size309);
+ uint32_t _i313;
+ for (_i313 = 0; _i313 < _size309; ++_i313)
{
- xfer += this->parts[_i287].read(iprot);
+ xfer += this->parts[_i313].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5939,10 +6404,10 @@ uint32_t AddPartitionsRequest::write(::a
xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->parts.size()));
- std::vector<Partition> ::const_iterator _iter288;
- for (_iter288 = this->parts.begin(); _iter288 != this->parts.end(); ++_iter288)
+ std::vector<Partition> ::const_iterator _iter314;
+ for (_iter314 = this->parts.begin(); _iter314 != this->parts.end(); ++_iter314)
{
- xfer += (*_iter288).write(oprot);
+ xfer += (*_iter314).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5999,14 +6464,14 @@ uint32_t DropPartitionsResult::read(::ap
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size289;
- ::apache::thrift::protocol::TType _etype292;
- xfer += iprot->readListBegin(_etype292, _size289);
- this->partitions.resize(_size289);
- uint32_t _i293;
- for (_i293 = 0; _i293 < _size289; ++_i293)
+ uint32_t _size315;
+ ::apache::thrift::protocol::TType _etype318;
+ xfer += iprot->readListBegin(_etype318, _size315);
+ this->partitions.resize(_size315);
+ uint32_t _i319;
+ for (_i319 = 0; _i319 < _size315; ++_i319)
{
- xfer += this->partitions[_i293].read(iprot);
+ xfer += this->partitions[_i319].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -6035,10 +6500,10 @@ uint32_t DropPartitionsResult::write(::a
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter294;
- for (_iter294 = this->partitions.begin(); _iter294 != this->partitions.end(); ++_iter294)
+ std::vector<Partition> ::const_iterator _iter320;
+ for (_iter320 = this->partitions.begin(); _iter320 != this->partitions.end(); ++_iter320)
{
- xfer += (*_iter294).write(oprot);
+ xfer += (*_iter320).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6161,14 +6626,14 @@ uint32_t RequestPartsSpec::read(::apache
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->names.clear();
- uint32_t _size295;
- ::apache::thrift::protocol::TType _etype298;
- xfer += iprot->readListBegin(_etype298, _size295);
- this->names.resize(_size295);
- uint32_t _i299;
- for (_i299 = 0; _i299 < _size295; ++_i299)
+ uint32_t _size321;
+ ::apache::thrift::protocol::TType _etype324;
+ xfer += iprot->readListBegin(_etype324, _size321);
+ this->names.resize(_size321);
+ uint32_t _i325;
+ for (_i325 = 0; _i325 < _size321; ++_i325)
{
- xfer += iprot->readString(this->names[_i299]);
+ xfer += iprot->readString(this->names[_i325]);
}
xfer += iprot->readListEnd();
}
@@ -6181,14 +6646,14 @@ uint32_t RequestPartsSpec::read(::apache
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->exprs.clear();
- uint32_t _size300;
- ::apache::thrift::protocol::TType _etype303;
- xfer += iprot->readListBegin(_etype303, _size300);
- this->exprs.resize(_size300);
- uint32_t _i304;
- for (_i304 = 0; _i304 < _size300; ++_i304)
+ uint32_t _size326;
+ ::apache::thrift::protocol::TType _etype329;
+ xfer += iprot->readListBegin(_etype329, _size326);
+ this->exprs.resize(_size326);
+ uint32_t _i330;
+ for (_i330 = 0; _i330 < _size326; ++_i330)
{
- xfer += this->exprs[_i304].read(iprot);
+ xfer += this->exprs[_i330].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -6216,10 +6681,10 @@ uint32_t RequestPartsSpec::write(::apach
xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size()));
- std::vector<std::string> ::const_iterator _iter305;
- for (_iter305 = this->names.begin(); _iter305 != this->names.end(); ++_iter305)
+ std::vector<std::string> ::const_iterator _iter331;
+ for (_iter331 = this->names.begin(); _iter331 != this->names.end(); ++_iter331)
{
- xfer += oprot->writeString((*_iter305));
+ xfer += oprot->writeString((*_iter331));
}
xfer += oprot->writeListEnd();
}
@@ -6228,10 +6693,10 @@ uint32_t RequestPartsSpec::write(::apach
xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->exprs.size()));
- std::vector<DropPartitionsExpr> ::const_iterator _iter306;
- for (_iter306 = this->exprs.begin(); _iter306 != this->exprs.end(); ++_iter306)
+ std::vector<DropPartitionsExpr> ::const_iterator _iter332;
+ for (_iter332 = this->exprs.begin(); _iter332 != this->exprs.end(); ++_iter332)
{
- xfer += (*_iter306).write(oprot);
+ xfer += (*_iter332).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6441,9 +6906,9 @@ uint32_t ResourceUri::read(::apache::thr
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast307;
- xfer += iprot->readI32(ecast307);
- this->resourceType = (ResourceType::type)ecast307;
+ int32_t ecast333;
+ xfer += iprot->readI32(ecast333);
+ this->resourceType = (ResourceType::type)ecast333;
this->__isset.resourceType = true;
} else {
xfer += iprot->skip(ftype);
@@ -6550,9 +7015,9 @@ uint32_t Function::read(::apache::thrift
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast308;
- xfer += iprot->readI32(ecast308);
- this->ownerType = (PrincipalType::type)ecast308;
+ int32_t ecast334;
+ xfer += iprot->readI32(ecast334);
+ this->ownerType = (PrincipalType::type)ecast334;
this->__isset.ownerType = true;
} else {
xfer += iprot->skip(ftype);
@@ -6568,9 +7033,9 @@ uint32_t Function::read(::apache::thrift
break;
case 7:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast309;
- xfer += iprot->readI32(ecast309);
- this->functionType = (FunctionType::type)ecast309;
+ int32_t ecast335;
+ xfer += iprot->readI32(ecast335);
+ this->functionType = (FunctionType::type)ecast335;
this->__isset.functionType = true;
} else {
xfer += iprot->skip(ftype);
@@ -6580,14 +7045,14 @@ uint32_t Function::read(::apache::thrift
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->resourceUris.clear();
- uint32_t _size310;
- ::apache::thrift::protocol::TType _etype313;
- xfer += iprot->readListBegin(_etype313, _size310);
- this->resourceUris.resize(_size310);
- uint32_t _i314;
- for (_i314 = 0; _i314 < _size310; ++_i314)
+ uint32_t _size336;
+ ::apache::thrift::protocol::TType _etype339;
+ xfer += iprot->readListBegin(_etype339, _size336);
+ this->resourceUris.resize(_size336);
+ uint32_t _i340;
+ for (_i340 = 0; _i340 < _size336; ++_i340)
{
- xfer += this->resourceUris[_i314].read(iprot);
+ xfer += this->resourceUris[_i340].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -6643,10 +7108,10 @@ uint32_t Function::write(::apache::thrif
xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->resourceUris.size()));
- std::vector<ResourceUri> ::const_iterator _iter315;
- for (_iter315 = this->resourceUris.begin(); _iter315 != this->resourceUris.end(); ++_iter315)
+ std::vector<ResourceUri> ::const_iterator _iter341;
+ for (_iter341 = this->resourceUris.begin(); _iter341 != this->resourceUris.end(); ++_iter341)
{
- xfer += (*_iter315).write(oprot);
+ xfer += (*_iter341).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6707,9 +7172,9 @@ uint32_t TxnInfo::read(::apache::thrift:
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast316;
- xfer += iprot->readI32(ecast316);
- this->state = (TxnState::type)ecast316;
+ int32_t ecast342;
+ xfer += iprot->readI32(ecast342);
+ this->state = (TxnState::type)ecast342;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -6821,14 +7286,14 @@ uint32_t GetOpenTxnsInfoResponse::read(:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- uint32_t _size317;
- ::apache::thrift::protocol::TType _etype320;
- xfer += iprot->readListBegin(_etype320, _size317);
- this->open_txns.resize(_size317);
- uint32_t _i321;
- for (_i321 = 0; _i321 < _size317; ++_i321)
+ uint32_t _size343;
+ ::apache::thrift::protocol::TType _etype346;
+ xfer += iprot->readListBegin(_etype346, _size343);
+ this->open_txns.resize(_size343);
+ uint32_t _i347;
+ for (_i347 = 0; _i347 < _size343; ++_i347)
{
- xfer += this->open_txns[_i321].read(iprot);
+ xfer += this->open_txns[_i347].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -6864,10 +7329,10 @@ uint32_t GetOpenTxnsInfoResponse::write(
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->open_txns.size()));
- std::vector<TxnInfo> ::const_iterator _iter322;
- for (_iter322 = this->open_txns.begin(); _iter322 != this->open_txns.end(); ++_iter322)
+ std::vector<TxnInfo> ::const_iterator _iter348;
+ for (_iter348 = this->open_txns.begin(); _iter348 != this->open_txns.end(); ++_iter348)
{
- xfer += (*_iter322).write(oprot);
+ xfer += (*_iter348).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6921,15 +7386,15 @@ uint32_t GetOpenTxnsResponse::read(::apa
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->open_txns.clear();
- uint32_t _size323;
- ::apache::thrift::protocol::TType _etype326;
- xfer += iprot->readSetBegin(_etype326, _size323);
- uint32_t _i327;
- for (_i327 = 0; _i327 < _size323; ++_i327)
+ uint32_t _size349;
+ ::apache::thrift::protocol::TType _etype352;
+ xfer += iprot->readSetBegin(_etype352, _size349);
+ uint32_t _i353;
+ for (_i353 = 0; _i353 < _size349; ++_i353)
{
- int64_t _elem328;
- xfer += iprot->readI64(_elem328);
- this->open_txns.insert(_elem328);
+ int64_t _elem354;
+ xfer += iprot->readI64(_elem354);
+ this->open_txns.insert(_elem354);
}
xfer += iprot->readSetEnd();
}
@@ -6965,10 +7430,10 @@ uint32_t GetOpenTxnsResponse::write(::ap
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
- std::set<int64_t> ::const_iterator _iter329;
- for (_iter329 = this->open_txns.begin(); _iter329 != this->open_txns.end(); ++_iter329)
+ std::set<int64_t> ::const_iterator _iter355;
+ for (_iter355 = this->open_txns.begin(); _iter355 != this->open_txns.end(); ++_iter355)
{
- xfer += oprot->writeI64((*_iter329));
+ xfer += oprot->writeI64((*_iter355));
}
xfer += oprot->writeSetEnd();
}
@@ -7109,14 +7574,14 @@ uint32_t OpenTxnsResponse::read(::apache
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size330;
- ::apache::thrift::protocol::TType _etype333;
- xfer += iprot->readListBegin(_etype333, _size330);
- this->txn_ids.resize(_size330);
- uint32_t _i334;
- for (_i334 = 0; _i334 < _size330; ++_i334)
+ uint32_t _size356;
+ ::apache::thrift::protocol::TType _etype359;
+ xfer += iprot->readListBegin(_etype359, _size356);
+ this->txn_ids.resize(_size356);
+ uint32_t _i360;
+ for (_i360 = 0; _i360 < _size356; ++_i360)
{
- xfer += iprot->readI64(this->txn_ids[_i334]);
+ xfer += iprot->readI64(this->txn_ids[_i360]);
}
xfer += iprot->readListEnd();
}
@@ -7146,10 +7611,10 @@ uint32_t OpenTxnsResponse::write(::apach
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter335;
- for (_iter335 = this->txn_ids.begin(); _iter335 != this->txn_ids.end(); ++_iter335)
+ std::vector<int64_t> ::const_iterator _iter361;
+ for (_iter361 = this->txn_ids.begin(); _iter361 != this->txn_ids.end(); ++_iter361)
{
- xfer += oprot->writeI64((*_iter335));
+ xfer += oprot->writeI64((*_iter361));
}
xfer += oprot->writeListEnd();
}
@@ -7321,9 +7786,9 @@ uint32_t LockComponent::read(::apache::t
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast336;
- xfer += iprot->readI32(ecast336);
- this->type = (LockType::type)ecast336;
+ int32_t ecast362;
+ xfer += iprot->readI32(ecast362);
+ this->type = (LockType::type)ecast362;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -7331,9 +7796,9 @@ uint32_t LockComponent::read(::apache::t
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast337;
- xfer += iprot->readI32(ecast337);
- this->level = (LockLevel::type)ecast337;
+ int32_t ecast363;
+ xfer += iprot->readI32(ecast363);
+ this->level = (LockLevel::type)ecast363;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -7452,14 +7917,14 @@ uint32_t LockRequest::read(::apache::thr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size338;
- ::apache::thrift::protocol::TType _etype341;
- xfer += iprot->readListBegin(_etype341, _size338);
- this->component.resize(_size338);
- uint32_t _i342;
- for (_i342 = 0; _i342 < _size338; ++_i342)
+ uint32_t _size364;
+ ::apache::thrift::protocol::TType _etype367;
+ xfer += iprot->readListBegin(_etype367, _size364);
+ this->component.resize(_size364);
+ uint32_t _i368;
+ for (_i368 = 0; _i368 < _size364; ++_i368)
{
- xfer += this->component[_i342].read(iprot);
+ xfer += this->component[_i368].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7517,10 +7982,10 @@ uint32_t LockRequest::write(::apache::th
xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->component.size()));
- std::vector<LockComponent> ::const_iterator _iter343;
- for (_iter343 = this->component.begin(); _iter343 != this->component.end(); ++_iter343)
+ std::vector<LockComponent> ::const_iterator _iter369;
+ for (_iter369 = this->component.begin(); _iter369 != this->component.end(); ++_iter369)
{
- xfer += (*_iter343).write(oprot);
+ xfer += (*_iter369).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7588,9 +8053,9 @@ uint32_t LockResponse::read(::apache::th
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast344;
- xfer += iprot->readI32(ecast344);
- this->state = (LockState::type)ecast344;
+ int32_t ecast370;
+ xfer += iprot->readI32(ecast370);
+ this->state = (LockState::type)ecast370;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -7872,9 +8337,9 @@ uint32_t ShowLocksResponseElement::read(
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast345;
- xfer += iprot->readI32(ecast345);
- this->state = (LockState::type)ecast345;
+ int32_t ecast371;
+ xfer += iprot->readI32(ecast371);
+ this->state = (LockState::type)ecast371;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -7882,9 +8347,9 @@ uint32_t ShowLocksResponseElement::read(
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast346;
- xfer += iprot->readI32(ecast346);
- this->type = (LockType::type)ecast346;
+ int32_t ecast372;
+ xfer += iprot->readI32(ecast372);
+ this->type = (LockType::type)ecast372;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -8056,14 +8521,14 @@ uint32_t ShowLocksResponse::read(::apach
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size347;
- ::apache::thrift::protocol::TType _etype350;
- xfer += iprot->readListBegin(_etype350, _size347);
- this->locks.resize(_size347);
- uint32_t _i351;
- for (_i351 = 0; _i351 < _size347; ++_i351)
+ uint32_t _size373;
+ ::apache::thrift::protocol::TType _etype376;
+ xfer += iprot->readListBegin(_etype376, _size373);
+ this->locks.resize(_size373);
+ uint32_t _i377;
+ for (_i377 = 0; _i377 < _size373; ++_i377)
{
- xfer += this->locks[_i351].read(iprot);
+ xfer += this->locks[_i377].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8091,10 +8556,10 @@ uint32_t ShowLocksResponse::write(::apac
xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->locks.size()));
- std::vector<ShowLocksResponseElement> ::const_iterator _iter352;
- for (_iter352 = this->locks.begin(); _iter352 != this->locks.end(); ++_iter352)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter378;
+ for (_iter378 = this->locks.begin(); _iter378 != this->locks.end(); ++_iter378)
{
- xfer += (*_iter352).write(oprot);
+ xfer += (*_iter378).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8297,15 +8762,15 @@ uint32_t HeartbeatTxnRangeResponse::read
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size353;
- ::apache::thrift::protocol::TType _etype356;
- xfer += iprot->readSetBegin(_etype356, _size353);
- uint32_t _i357;
- for (_i357 = 0; _i357 < _size353; ++_i357)
+ uint32_t _size379;
+ ::apache::thrift::protocol::TType _etype382;
+ xfer += iprot->readSetBegin(_etype382, _size379);
+ uint32_t _i383;
+ for (_i383 = 0; _i383 < _size379; ++_i383)
{
- int64_t _elem358;
- xfer += iprot->readI64(_elem358);
- this->aborted.insert(_elem358);
+ int64_t _elem384;
+ xfer += iprot->readI64(_elem384);
+ this->aborted.insert(_elem384);
}
xfer += iprot->readSetEnd();
}
@@ -8318,15 +8783,15 @@ uint32_t HeartbeatTxnRangeResponse::read
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size359;
- ::apache::thrift::protocol::TType _etype362;
- xfer += iprot->readSetBegin(_etype362, _size359);
- uint32_t _i363;
- for (_i363 = 0; _i363 < _size359; ++_i363)
+ uint32_t _size385;
+ ::apache::thrift::protocol::TType _etype388;
+ xfer += iprot->readSetBegin(_etype388, _size385);
+ uint32_t _i389;
+ for (_i389 = 0; _i389 < _size385; ++_i389)
{
- int64_t _elem364;
- xfer += iprot->readI64(_elem364);
- this->nosuch.insert(_elem364);
+ int64_t _elem390;
+ xfer += iprot->readI64(_elem390);
+ this->nosuch.insert(_elem390);
}
xfer += iprot->readSetEnd();
}
@@ -8358,10 +8823,10 @@ uint32_t HeartbeatTxnRangeResponse::writ
xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->aborted.size()));
- std::set<int64_t> ::const_iterator _iter365;
- for (_iter365 = this->aborted.begin(); _iter365 != this->aborted.end(); ++_iter365)
+ std::set<int64_t> ::const_iterator _iter391;
+ for (_iter391 = this->aborted.begin(); _iter391 != this->aborted.end(); ++_iter391)
{
- xfer += oprot->writeI64((*_iter365));
+ xfer += oprot->writeI64((*_iter391));
}
xfer += oprot->writeSetEnd();
}
@@ -8370,10 +8835,10 @@ uint32_t HeartbeatTxnRangeResponse::writ
xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->nosuch.size()));
- std::set<int64_t> ::const_iterator _iter366;
- for (_iter366 = this->nosuch.begin(); _iter366 != this->nosuch.end(); ++_iter366)
+ std::set<int64_t> ::const_iterator _iter392;
+ for (_iter392 = this->nosuch.begin(); _iter392 != this->nosuch.end(); ++_iter392)
{
- xfer += oprot->writeI64((*_iter366));
+ xfer += oprot->writeI64((*_iter392));
}
xfer += oprot->writeSetEnd();
}
@@ -8442,9 +8907,9 @@ uint32_t CompactionRequest::read(::apach
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast367;
- xfer += iprot->readI32(ecast367);
- this->type = (CompactionType::type)ecast367;
+ int32_t ecast393;
+ xfer += iprot->readI32(ecast393);
+ this->type = (CompactionType::type)ecast393;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -8619,9 +9084,9 @@ uint32_t ShowCompactResponseElement::rea
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast368;
- xfer += iprot->readI32(ecast368);
- this->type = (CompactionType::type)ecast368;
+ int32_t ecast394;
+ xfer += iprot->readI32(ecast394);
+ this->type = (CompactionType::type)ecast394;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -8768,14 +9233,14 @@ uint32_t ShowCompactResponse::read(::apa
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size369;
- ::apache::thrift::protocol::TType _etype372;
- xfer += iprot->readListBegin(_etype372, _size369);
- this->compacts.resize(_size369);
- uint32_t _i373;
- for (_i373 = 0; _i373 < _size369; ++_i373)
+ uint32_t _size395;
+ ::apache::thrift::protocol::TType _etype398;
+ xfer += iprot->readListBegin(_etype398, _size395);
+ this->compacts.resize(_size395);
+ uint32_t _i399;
+ for (_i399 = 0; _i399 < _size395; ++_i399)
{
- xfer += this->compacts[_i373].read(iprot);
+ xfer += this->compacts[_i399].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8805,10 +9270,10 @@ uint32_t ShowCompactResponse::write(::ap
xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->compacts.size()));
- std::vector<ShowCompactResponseElement> ::const_iterator _iter374;
- for (_iter374 = this->compacts.begin(); _iter374 != this->compacts.end(); ++_iter374)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter400;
+ for (_iter400 = this->compacts.begin(); _iter400 != this->compacts.end(); ++_iter400)
{
- xfer += (*_iter374).write(oprot);
+ xfer += (*_iter400).write(oprot);
}
xfer += oprot->writeListEnd();
}
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1622763&r1=1622762&r2=1622763&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Fri Sep 5 19:15:44 2014
@@ -1849,6 +1849,267 @@ class Partition {
void swap(Partition &a, Partition &b);
+typedef struct _PartitionWithoutSD__isset {
+ _PartitionWithoutSD__isset() : values(false), createTime(false), lastAccessTime(false), relativePath(false), parameters(false), privileges(false) {}
+ bool values;
+ bool createTime;
+ bool lastAccessTime;
+ bool relativePath;
+ bool parameters;
+ bool privileges;
+} _PartitionWithoutSD__isset;
+
+class PartitionWithoutSD {
+ public:
+
+ static const char* ascii_fingerprint; // = "D79FA44499888D0E50B5625E0C536DEA";
+ static const uint8_t binary_fingerprint[16]; // = {0xD7,0x9F,0xA4,0x44,0x99,0x88,0x8D,0x0E,0x50,0xB5,0x62,0x5E,0x0C,0x53,0x6D,0xEA};
+
+ PartitionWithoutSD() : createTime(0), lastAccessTime(0), relativePath() {
+ }
+
+ virtual ~PartitionWithoutSD() throw() {}
+
+ std::vector<std::string> values;
+ int32_t createTime;
+ int32_t lastAccessTime;
+ std::string relativePath;
+ std::map<std::string, std::string> parameters;
+ PrincipalPrivilegeSet privileges;
+
+ _PartitionWithoutSD__isset __isset;
+
+ void __set_values(const std::vector<std::string> & val) {
+ values = val;
+ }
+
+ void __set_createTime(const int32_t val) {
+ createTime = val;
+ }
+
+ void __set_lastAccessTime(const int32_t val) {
+ lastAccessTime = val;
+ }
+
+ void __set_relativePath(const std::string& val) {
+ relativePath = val;
+ }
+
+ void __set_parameters(const std::map<std::string, std::string> & val) {
+ parameters = val;
+ }
+
+ void __set_privileges(const PrincipalPrivilegeSet& val) {
+ privileges = val;
+ __isset.privileges = true;
+ }
+
+ bool operator == (const PartitionWithoutSD & rhs) const
+ {
+ if (!(values == rhs.values))
+ return false;
+ if (!(createTime == rhs.createTime))
+ return false;
+ if (!(lastAccessTime == rhs.lastAccessTime))
+ return false;
+ if (!(relativePath == rhs.relativePath))
+ return false;
+ if (!(parameters == rhs.parameters))
+ return false;
+ if (__isset.privileges != rhs.__isset.privileges)
+ return false;
+ else if (__isset.privileges && !(privileges == rhs.privileges))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionWithoutSD &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionWithoutSD & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionWithoutSD &a, PartitionWithoutSD &b);
+
+typedef struct _PartitionSpecWithSharedSD__isset {
+ _PartitionSpecWithSharedSD__isset() : partitions(false), sd(false) {}
+ bool partitions;
+ bool sd;
+} _PartitionSpecWithSharedSD__isset;
+
+class PartitionSpecWithSharedSD {
+ public:
+
+ static const char* ascii_fingerprint; // = "7BEE9305B42DCD083FF06BEE6DDC61CF";
+ static const uint8_t binary_fingerprint[16]; // = {0x7B,0xEE,0x93,0x05,0xB4,0x2D,0xCD,0x08,0x3F,0xF0,0x6B,0xEE,0x6D,0xDC,0x61,0xCF};
+
+ PartitionSpecWithSharedSD() {
+ }
+
+ virtual ~PartitionSpecWithSharedSD() throw() {}
+
+ std::vector<PartitionWithoutSD> partitions;
+ StorageDescriptor sd;
+
+ _PartitionSpecWithSharedSD__isset __isset;
+
+ void __set_partitions(const std::vector<PartitionWithoutSD> & val) {
+ partitions = val;
+ }
+
+ void __set_sd(const StorageDescriptor& val) {
+ sd = val;
+ }
+
+ bool operator == (const PartitionSpecWithSharedSD & rhs) const
+ {
+ if (!(partitions == rhs.partitions))
+ return false;
+ if (!(sd == rhs.sd))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionSpecWithSharedSD &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionSpecWithSharedSD & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b);
+
+typedef struct _PartitionListComposingSpec__isset {
+ _PartitionListComposingSpec__isset() : partitions(false) {}
+ bool partitions;
+} _PartitionListComposingSpec__isset;
+
+class PartitionListComposingSpec {
+ public:
+
+ static const char* ascii_fingerprint; // = "A048235CB9A257C8A74E3691BEFE0674";
+ static const uint8_t binary_fingerprint[16]; // = {0xA0,0x48,0x23,0x5C,0xB9,0xA2,0x57,0xC8,0xA7,0x4E,0x36,0x91,0xBE,0xFE,0x06,0x74};
+
+ PartitionListComposingSpec() {
+ }
+
+ virtual ~PartitionListComposingSpec() throw() {}
+
+ std::vector<Partition> partitions;
+
+ _PartitionListComposingSpec__isset __isset;
+
+ void __set_partitions(const std::vector<Partition> & val) {
+ partitions = val;
+ }
+
+ bool operator == (const PartitionListComposingSpec & rhs) const
+ {
+ if (!(partitions == rhs.partitions))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionListComposingSpec &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionListComposingSpec & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b);
+
+typedef struct _PartitionSpec__isset {
+ _PartitionSpec__isset() : dbName(false), tableName(false), rootPath(false), sharedSDPartitionSpec(false), partitionList(false) {}
+ bool dbName;
+ bool tableName;
+ bool rootPath;
+ bool sharedSDPartitionSpec;
+ bool partitionList;
+} _PartitionSpec__isset;
+
+class PartitionSpec {
+ public:
+
+ static const char* ascii_fingerprint; // = "C3F548C24D072CF6422F25096143E3E8";
+ static const uint8_t binary_fingerprint[16]; // = {0xC3,0xF5,0x48,0xC2,0x4D,0x07,0x2C,0xF6,0x42,0x2F,0x25,0x09,0x61,0x43,0xE3,0xE8};
+
+ PartitionSpec() : dbName(), tableName(), rootPath() {
+ }
+
+ virtual ~PartitionSpec() throw() {}
+
+ std::string dbName;
+ std::string tableName;
+ std::string rootPath;
+ PartitionSpecWithSharedSD sharedSDPartitionSpec;
+ PartitionListComposingSpec partitionList;
+
+ _PartitionSpec__isset __isset;
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ }
+
+ void __set_tableName(const std::string& val) {
+ tableName = val;
+ }
+
+ void __set_rootPath(const std::string& val) {
+ rootPath = val;
+ }
+
+ void __set_sharedSDPartitionSpec(const PartitionSpecWithSharedSD& val) {
+ sharedSDPartitionSpec = val;
+ __isset.sharedSDPartitionSpec = true;
+ }
+
+ void __set_partitionList(const PartitionListComposingSpec& val) {
+ partitionList = val;
+ __isset.partitionList = true;
+ }
+
+ bool operator == (const PartitionSpec & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tableName == rhs.tableName))
+ return false;
+ if (!(rootPath == rhs.rootPath))
+ return false;
+ if (__isset.sharedSDPartitionSpec != rhs.__isset.sharedSDPartitionSpec)
+ return false;
+ else if (__isset.sharedSDPartitionSpec && !(sharedSDPartitionSpec == rhs.sharedSDPartitionSpec))
+ return false;
+ if (__isset.partitionList != rhs.__isset.partitionList)
+ return false;
+ else if (__isset.partitionList && !(partitionList == rhs.partitionList))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionSpec &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionSpec & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionSpec &a, PartitionSpec &b);
+
typedef struct _Index__isset {
_Index__isset() : indexName(false), indexHandlerClass(false), dbName(false), origTableName(false), createTime(false), lastAccessTime(false), indexTableName(false), sd(false), parameters(false), deferredRebuild(false) {}
bool indexName;
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java?rev=1622763&r1=1622762&r2=1622763&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java Fri Sep 5 19:15:44 2014
@@ -700,14 +700,14 @@ public class AddPartitionsRequest implem
case 3: // PARTS
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
- org.apache.thrift.protocol.TList _list354 = iprot.readListBegin();
- struct.parts = new ArrayList<Partition>(_list354.size);
- for (int _i355 = 0; _i355 < _list354.size; ++_i355)
+ org.apache.thrift.protocol.TList _list388 = iprot.readListBegin();
+ struct.parts = new ArrayList<Partition>(_list388.size);
+ for (int _i389 = 0; _i389 < _list388.size; ++_i389)
{
- Partition _elem356; // required
- _elem356 = new Partition();
- _elem356.read(iprot);
- struct.parts.add(_elem356);
+ Partition _elem390; // required
+ _elem390 = new Partition();
+ _elem390.read(iprot);
+ struct.parts.add(_elem390);
}
iprot.readListEnd();
}
@@ -759,9 +759,9 @@ public class AddPartitionsRequest implem
oprot.writeFieldBegin(PARTS_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.parts.size()));
- for (Partition _iter357 : struct.parts)
+ for (Partition _iter391 : struct.parts)
{
- _iter357.write(oprot);
+ _iter391.write(oprot);
}
oprot.writeListEnd();
}
@@ -796,9 +796,9 @@ public class AddPartitionsRequest implem
oprot.writeString(struct.tblName);
{
oprot.writeI32(struct.parts.size());
- for (Partition _iter358 : struct.parts)
+ for (Partition _iter392 : struct.parts)
{
- _iter358.write(oprot);
+ _iter392.write(oprot);
}
}
oprot.writeBool(struct.ifNotExists);
@@ -820,14 +820,14 @@ public class AddPartitionsRequest implem
struct.tblName = iprot.readString();
struct.setTblNameIsSet(true);
{
- org.apache.thrift.protocol.TList _list359 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
- struct.parts = new ArrayList<Partition>(_list359.size);
- for (int _i360 = 0; _i360 < _list359.size; ++_i360)
+ org.apache.thrift.protocol.TList _list393 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+ struct.parts = new ArrayList<Partition>(_list393.size);
+ for (int _i394 = 0; _i394 < _list393.size; ++_i394)
{
- Partition _elem361; // required
- _elem361 = new Partition();
- _elem361.read(iprot);
- struct.parts.add(_elem361);
+ Partition _elem395; // required
+ _elem395 = new Partition();
+ _elem395.read(iprot);
+ struct.parts.add(_elem395);
}
}
struct.setPartsIsSet(true);
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java?rev=1622763&r1=1622762&r2=1622763&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java Fri Sep 5 19:15:44 2014
@@ -342,14 +342,14 @@ public class AddPartitionsResult impleme
case 1: // PARTITIONS
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
- org.apache.thrift.protocol.TList _list346 = iprot.readListBegin();
- struct.partitions = new ArrayList<Partition>(_list346.size);
- for (int _i347 = 0; _i347 < _list346.size; ++_i347)
+ org.apache.thrift.protocol.TList _list380 = iprot.readListBegin();
+ struct.partitions = new ArrayList<Partition>(_list380.size);
+ for (int _i381 = 0; _i381 < _list380.size; ++_i381)
{
- Partition _elem348; // required
- _elem348 = new Partition();
- _elem348.read(iprot);
- struct.partitions.add(_elem348);
+ Partition _elem382; // required
+ _elem382 = new Partition();
+ _elem382.read(iprot);
+ struct.partitions.add(_elem382);
}
iprot.readListEnd();
}
@@ -376,9 +376,9 @@ public class AddPartitionsResult impleme
oprot.writeFieldBegin(PARTITIONS_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size()));
- for (Partition _iter349 : struct.partitions)
+ for (Partition _iter383 : struct.partitions)
{
- _iter349.write(oprot);
+ _iter383.write(oprot);
}
oprot.writeListEnd();
}
@@ -410,9 +410,9 @@ public class AddPartitionsResult impleme
if (struct.isSetPartitions()) {
{
oprot.writeI32(struct.partitions.size());
- for (Partition _iter350 : struct.partitions)
+ for (Partition _iter384 : struct.partitions)
{
- _iter350.write(oprot);
+ _iter384.write(oprot);
}
}
}
@@ -424,14 +424,14 @@ public class AddPartitionsResult impleme
BitSet incoming = iprot.readBitSet(1);
if (incoming.get(0)) {
{
- org.apache.thrift.protocol.TList _list351 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
- struct.partitions = new ArrayList<Partition>(_list351.size);
- for (int _i352 = 0; _i352 < _list351.size; ++_i352)
+ org.apache.thrift.protocol.TList _list385 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+ struct.partitions = new ArrayList<Partition>(_list385.size);
+ for (int _i386 = 0; _i386 < _list385.size; ++_i386)
{
- Partition _elem353; // required
- _elem353 = new Partition();
- _elem353.read(iprot);
- struct.partitions.add(_elem353);
+ Partition _elem387; // required
+ _elem387 = new Partition();
+ _elem387.read(iprot);
+ struct.partitions.add(_elem387);
}
}
struct.setPartitionsIsSet(true);