http://git-wip-us.apache.org/repos/asf/hive/blob/117c3b47/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index ed847cd..598d887 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -4484,6 +4484,11 @@ void Table::__set_rewriteEnabled(const bool val) { __isset.rewriteEnabled = true; } +void Table::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} + uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -4652,6 +4657,16 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 16: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast219; + xfer += iprot->readI32(ecast219); + this->ownerType = (PrincipalType::type)ecast219; + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4700,10 +4715,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size())); - std::vector<FieldSchema> ::const_iterator _iter219; - for (_iter219 = this->partitionKeys.begin(); _iter219 != this->partitionKeys.end(); ++_iter219) + std::vector<FieldSchema> ::const_iterator _iter220; + for (_iter220 = this->partitionKeys.begin(); _iter220 != this->partitionKeys.end(); ++_iter220) { - xfer += (*_iter219).write(oprot); + xfer += (*_iter220).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4712,11 +4727,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter220; - for (_iter220 = this->parameters.begin(); _iter220 != this->parameters.end(); ++_iter220) + std::map<std::string, std::string> ::const_iterator _iter221; + for (_iter221 = this->parameters.begin(); _iter221 != this->parameters.end(); ++_iter221) { - xfer += oprot->writeString(_iter220->first); - xfer += oprot->writeString(_iter220->second); + xfer += oprot->writeString(_iter221->first); + xfer += oprot->writeString(_iter221->second); } xfer += oprot->writeMapEnd(); } @@ -4749,6 +4764,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeBool(this->rewriteEnabled); xfer += oprot->writeFieldEnd(); } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 16); + xfer += oprot->writeI32((int32_t)this->ownerType); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -4771,28 +4791,11 @@ void swap(Table &a, Table &b) { swap(a.privileges, b.privileges); swap(a.temporary, b.temporary); swap(a.rewriteEnabled, b.rewriteEnabled); + swap(a.ownerType, b.ownerType); swap(a.__isset, b.__isset); } -Table::Table(const Table& other221) { - tableName = other221.tableName; - dbName = other221.dbName; - owner = other221.owner; - createTime = other221.createTime; - lastAccessTime = other221.lastAccessTime; - retention = other221.retention; - sd = other221.sd; - partitionKeys = other221.partitionKeys; - parameters = other221.parameters; - viewOriginalText = other221.viewOriginalText; - viewExpandedText = other221.viewExpandedText; - tableType = other221.tableType; - privileges = other221.privileges; - temporary = other221.temporary; - rewriteEnabled = other221.rewriteEnabled; - __isset = other221.__isset; -} -Table& Table::operator=(const Table& other222) { +Table::Table(const Table& other222) { tableName = other222.tableName; dbName = other222.dbName; owner = other222.owner; @@ -4808,7 +4811,27 @@ Table& Table::operator=(const Table& other222) { privileges = other222.privileges; temporary = other222.temporary; rewriteEnabled = other222.rewriteEnabled; + ownerType = other222.ownerType; __isset = other222.__isset; +} +Table& Table::operator=(const Table& other223) { + tableName = other223.tableName; + dbName = other223.dbName; + owner = other223.owner; + createTime = other223.createTime; + lastAccessTime = other223.lastAccessTime; + retention = other223.retention; + sd = other223.sd; + partitionKeys = other223.partitionKeys; + parameters = other223.parameters; + viewOriginalText = other223.viewOriginalText; + viewExpandedText = other223.viewExpandedText; + tableType = other223.tableType; + privileges = other223.privileges; + temporary = other223.temporary; + rewriteEnabled = other223.rewriteEnabled; + ownerType = other223.ownerType; + __isset = other223.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -4829,6 +4852,7 @@ void Table::printTo(std::ostream& out) const { out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "<null>")); out << ", " << "temporary="; (__isset.temporary ? (out << to_string(temporary)) : (out << "<null>")); out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "<null>")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "<null>")); out << ")"; } @@ -4895,14 +4919,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size223; - ::apache::thrift::protocol::TType _etype226; - xfer += iprot->readListBegin(_etype226, _size223); - this->values.resize(_size223); - uint32_t _i227; - for (_i227 = 0; _i227 < _size223; ++_i227) + uint32_t _size224; + ::apache::thrift::protocol::TType _etype227; + xfer += iprot->readListBegin(_etype227, _size224); + this->values.resize(_size224); + uint32_t _i228; + for (_i228 = 0; _i228 < _size224; ++_i228) { - xfer += iprot->readString(this->values[_i227]); + xfer += iprot->readString(this->values[_i228]); } xfer += iprot->readListEnd(); } @@ -4955,17 +4979,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size228; - ::apache::thrift::protocol::TType _ktype229; - ::apache::thrift::protocol::TType _vtype230; - xfer += iprot->readMapBegin(_ktype229, _vtype230, _size228); - uint32_t _i232; - for (_i232 = 0; _i232 < _size228; ++_i232) + uint32_t _size229; + ::apache::thrift::protocol::TType _ktype230; + ::apache::thrift::protocol::TType _vtype231; + xfer += iprot->readMapBegin(_ktype230, _vtype231, _size229); + uint32_t _i233; + for (_i233 = 0; _i233 < _size229; ++_i233) { - std::string _key233; - xfer += iprot->readString(_key233); - std::string& _val234 = this->parameters[_key233]; - xfer += iprot->readString(_val234); + std::string _key234; + xfer += iprot->readString(_key234); + std::string& _val235 = this->parameters[_key234]; + xfer += iprot->readString(_val235); } xfer += iprot->readMapEnd(); } @@ -5002,10 +5026,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter235; - for (_iter235 = this->values.begin(); _iter235 != this->values.end(); ++_iter235) + std::vector<std::string> ::const_iterator _iter236; + for (_iter236 = this->values.begin(); _iter236 != this->values.end(); ++_iter236) { - xfer += oprot->writeString((*_iter235)); + xfer += oprot->writeString((*_iter236)); } xfer += oprot->writeListEnd(); } @@ -5034,11 +5058,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7); { 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 _iter236; - for (_iter236 = this->parameters.begin(); _iter236 != this->parameters.end(); ++_iter236) + std::map<std::string, std::string> ::const_iterator _iter237; + for (_iter237 = this->parameters.begin(); _iter237 != this->parameters.end(); ++_iter237) { - xfer += oprot->writeString(_iter236->first); - xfer += oprot->writeString(_iter236->second); + xfer += oprot->writeString(_iter237->first); + xfer += oprot->writeString(_iter237->second); } xfer += oprot->writeMapEnd(); } @@ -5067,18 +5091,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other237) { - values = other237.values; - dbName = other237.dbName; - tableName = other237.tableName; - createTime = other237.createTime; - lastAccessTime = other237.lastAccessTime; - sd = other237.sd; - parameters = other237.parameters; - privileges = other237.privileges; - __isset = other237.__isset; -} -Partition& Partition::operator=(const Partition& other238) { +Partition::Partition(const Partition& other238) { values = other238.values; dbName = other238.dbName; tableName = other238.tableName; @@ -5088,6 +5101,17 @@ Partition& Partition::operator=(const Partition& other238) { parameters = other238.parameters; privileges = other238.privileges; __isset = other238.__isset; +} +Partition& Partition::operator=(const Partition& other239) { + values = other239.values; + dbName = other239.dbName; + tableName = other239.tableName; + createTime = other239.createTime; + lastAccessTime = other239.lastAccessTime; + sd = other239.sd; + parameters = other239.parameters; + privileges = other239.privileges; + __isset = other239.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5159,14 +5183,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size239; - ::apache::thrift::protocol::TType _etype242; - xfer += iprot->readListBegin(_etype242, _size239); - this->values.resize(_size239); - uint32_t _i243; - for (_i243 = 0; _i243 < _size239; ++_i243) + uint32_t _size240; + ::apache::thrift::protocol::TType _etype243; + xfer += iprot->readListBegin(_etype243, _size240); + this->values.resize(_size240); + uint32_t _i244; + for (_i244 = 0; _i244 < _size240; ++_i244) { - xfer += iprot->readString(this->values[_i243]); + xfer += iprot->readString(this->values[_i244]); } xfer += iprot->readListEnd(); } @@ -5203,17 +5227,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size244; - ::apache::thrift::protocol::TType _ktype245; - ::apache::thrift::protocol::TType _vtype246; - xfer += iprot->readMapBegin(_ktype245, _vtype246, _size244); - uint32_t _i248; - for (_i248 = 0; _i248 < _size244; ++_i248) + 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) { - std::string _key249; - xfer += iprot->readString(_key249); - std::string& _val250 = this->parameters[_key249]; - xfer += iprot->readString(_val250); + std::string _key250; + xfer += iprot->readString(_key250); + std::string& _val251 = this->parameters[_key250]; + xfer += iprot->readString(_val251); } xfer += iprot->readMapEnd(); } @@ -5250,10 +5274,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) 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 _iter251; - for (_iter251 = this->values.begin(); _iter251 != this->values.end(); ++_iter251) + std::vector<std::string> ::const_iterator _iter252; + for (_iter252 = this->values.begin(); _iter252 != this->values.end(); ++_iter252) { - xfer += oprot->writeString((*_iter251)); + xfer += oprot->writeString((*_iter252)); } xfer += oprot->writeListEnd(); } @@ -5274,11 +5298,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) 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 _iter252; - for (_iter252 = this->parameters.begin(); _iter252 != this->parameters.end(); ++_iter252) + std::map<std::string, std::string> ::const_iterator _iter253; + for (_iter253 = this->parameters.begin(); _iter253 != this->parameters.end(); ++_iter253) { - xfer += oprot->writeString(_iter252->first); - xfer += oprot->writeString(_iter252->second); + xfer += oprot->writeString(_iter253->first); + xfer += oprot->writeString(_iter253->second); } xfer += oprot->writeMapEnd(); } @@ -5305,16 +5329,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other253) { - values = other253.values; - createTime = other253.createTime; - lastAccessTime = other253.lastAccessTime; - relativePath = other253.relativePath; - parameters = other253.parameters; - privileges = other253.privileges; - __isset = other253.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other254) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other254) { values = other254.values; createTime = other254.createTime; lastAccessTime = other254.lastAccessTime; @@ -5322,6 +5337,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other254.parameters; privileges = other254.privileges; __isset = other254.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other255) { + values = other255.values; + createTime = other255.createTime; + lastAccessTime = other255.lastAccessTime; + relativePath = other255.relativePath; + parameters = other255.parameters; + privileges = other255.privileges; + __isset = other255.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5374,14 +5398,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size255; - ::apache::thrift::protocol::TType _etype258; - xfer += iprot->readListBegin(_etype258, _size255); - this->partitions.resize(_size255); - uint32_t _i259; - for (_i259 = 0; _i259 < _size255; ++_i259) + uint32_t _size256; + ::apache::thrift::protocol::TType _etype259; + xfer += iprot->readListBegin(_etype259, _size256); + this->partitions.resize(_size256); + uint32_t _i260; + for (_i260 = 0; _i260 < _size256; ++_i260) { - xfer += this->partitions[_i259].read(iprot); + xfer += this->partitions[_i260].read(iprot); } xfer += iprot->readListEnd(); } @@ -5418,10 +5442,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* 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 _iter260; - for (_iter260 = this->partitions.begin(); _iter260 != this->partitions.end(); ++_iter260) + std::vector<PartitionWithoutSD> ::const_iterator _iter261; + for (_iter261 = this->partitions.begin(); _iter261 != this->partitions.end(); ++_iter261) { - xfer += (*_iter260).write(oprot); + xfer += (*_iter261).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5443,15 +5467,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other261) { - partitions = other261.partitions; - sd = other261.sd; - __isset = other261.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other262) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other262) { partitions = other262.partitions; sd = other262.sd; __isset = other262.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other263) { + partitions = other263.partitions; + sd = other263.sd; + __isset = other263.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5496,14 +5520,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size263; - ::apache::thrift::protocol::TType _etype266; - xfer += iprot->readListBegin(_etype266, _size263); - this->partitions.resize(_size263); - uint32_t _i267; - for (_i267 = 0; _i267 < _size263; ++_i267) + uint32_t _size264; + ::apache::thrift::protocol::TType _etype267; + xfer += iprot->readListBegin(_etype267, _size264); + this->partitions.resize(_size264); + uint32_t _i268; + for (_i268 = 0; _i268 < _size264; ++_i268) { - xfer += this->partitions[_i267].read(iprot); + xfer += this->partitions[_i268].read(iprot); } xfer += iprot->readListEnd(); } @@ -5532,10 +5556,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol 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 _iter268; - for (_iter268 = this->partitions.begin(); _iter268 != this->partitions.end(); ++_iter268) + std::vector<Partition> ::const_iterator _iter269; + for (_iter269 = this->partitions.begin(); _iter269 != this->partitions.end(); ++_iter269) { - xfer += (*_iter268).write(oprot); + xfer += (*_iter269).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5552,13 +5576,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other269) { - partitions = other269.partitions; - __isset = other269.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other270) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other270) { partitions = other270.partitions; __isset = other270.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other271) { + partitions = other271.partitions; + __isset = other271.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -5710,21 +5734,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other271) { - dbName = other271.dbName; - tableName = other271.tableName; - rootPath = other271.rootPath; - sharedSDPartitionSpec = other271.sharedSDPartitionSpec; - partitionList = other271.partitionList; - __isset = other271.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other272) { +PartitionSpec::PartitionSpec(const PartitionSpec& other272) { dbName = other272.dbName; tableName = other272.tableName; rootPath = other272.rootPath; sharedSDPartitionSpec = other272.sharedSDPartitionSpec; partitionList = other272.partitionList; __isset = other272.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other273) { + dbName = other273.dbName; + tableName = other273.tableName; + rootPath = other273.rootPath; + sharedSDPartitionSpec = other273.sharedSDPartitionSpec; + partitionList = other273.partitionList; + __isset = other273.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -5872,17 +5896,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size273; - ::apache::thrift::protocol::TType _ktype274; - ::apache::thrift::protocol::TType _vtype275; - xfer += iprot->readMapBegin(_ktype274, _vtype275, _size273); - uint32_t _i277; - for (_i277 = 0; _i277 < _size273; ++_i277) + uint32_t _size274; + ::apache::thrift::protocol::TType _ktype275; + ::apache::thrift::protocol::TType _vtype276; + xfer += iprot->readMapBegin(_ktype275, _vtype276, _size274); + uint32_t _i278; + for (_i278 = 0; _i278 < _size274; ++_i278) { - std::string _key278; - xfer += iprot->readString(_key278); - std::string& _val279 = this->parameters[_key278]; - xfer += iprot->readString(_val279); + std::string _key279; + xfer += iprot->readString(_key279); + std::string& _val280 = this->parameters[_key279]; + xfer += iprot->readString(_val280); } xfer += iprot->readMapEnd(); } @@ -5951,11 +5975,11 @@ uint32_t Index::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter280; - for (_iter280 = this->parameters.begin(); _iter280 != this->parameters.end(); ++_iter280) + std::map<std::string, std::string> ::const_iterator _iter281; + for (_iter281 = this->parameters.begin(); _iter281 != this->parameters.end(); ++_iter281) { - xfer += oprot->writeString(_iter280->first); - xfer += oprot->writeString(_iter280->second); + xfer += oprot->writeString(_iter281->first); + xfer += oprot->writeString(_iter281->second); } xfer += oprot->writeMapEnd(); } @@ -5985,20 +6009,7 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other281) { - indexName = other281.indexName; - indexHandlerClass = other281.indexHandlerClass; - dbName = other281.dbName; - origTableName = other281.origTableName; - createTime = other281.createTime; - lastAccessTime = other281.lastAccessTime; - indexTableName = other281.indexTableName; - sd = other281.sd; - parameters = other281.parameters; - deferredRebuild = other281.deferredRebuild; - __isset = other281.__isset; -} -Index& Index::operator=(const Index& other282) { +Index::Index(const Index& other282) { indexName = other282.indexName; indexHandlerClass = other282.indexHandlerClass; dbName = other282.dbName; @@ -6010,6 +6021,19 @@ Index& Index::operator=(const Index& other282) { parameters = other282.parameters; deferredRebuild = other282.deferredRebuild; __isset = other282.__isset; +} +Index& Index::operator=(const Index& other283) { + indexName = other283.indexName; + indexHandlerClass = other283.indexHandlerClass; + dbName = other283.dbName; + origTableName = other283.origTableName; + createTime = other283.createTime; + lastAccessTime = other283.lastAccessTime; + indexTableName = other283.indexTableName; + sd = other283.sd; + parameters = other283.parameters; + deferredRebuild = other283.deferredRebuild; + __isset = other283.__isset; return *this; } void Index::printTo(std::ostream& out) const { @@ -6160,19 +6184,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other283) { - numTrues = other283.numTrues; - numFalses = other283.numFalses; - numNulls = other283.numNulls; - bitVectors = other283.bitVectors; - __isset = other283.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other284) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other284) { numTrues = other284.numTrues; numFalses = other284.numFalses; numNulls = other284.numNulls; bitVectors = other284.bitVectors; __isset = other284.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other285) { + numTrues = other285.numTrues; + numFalses = other285.numFalses; + numNulls = other285.numNulls; + bitVectors = other285.bitVectors; + __isset = other285.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6335,21 +6359,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other285) { - lowValue = other285.lowValue; - highValue = other285.highValue; - numNulls = other285.numNulls; - numDVs = other285.numDVs; - bitVectors = other285.bitVectors; - __isset = other285.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other286) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other286) { lowValue = other286.lowValue; highValue = other286.highValue; numNulls = other286.numNulls; numDVs = other286.numDVs; bitVectors = other286.bitVectors; __isset = other286.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other287) { + lowValue = other287.lowValue; + highValue = other287.highValue; + numNulls = other287.numNulls; + numDVs = other287.numDVs; + bitVectors = other287.bitVectors; + __isset = other287.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -6513,21 +6537,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other287) { - lowValue = other287.lowValue; - highValue = other287.highValue; - numNulls = other287.numNulls; - numDVs = other287.numDVs; - bitVectors = other287.bitVectors; - __isset = other287.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other288) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other288) { lowValue = other288.lowValue; highValue = other288.highValue; numNulls = other288.numNulls; numDVs = other288.numDVs; bitVectors = other288.bitVectors; __isset = other288.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other289) { + lowValue = other289.lowValue; + highValue = other289.highValue; + numNulls = other289.numNulls; + numDVs = other289.numDVs; + bitVectors = other289.bitVectors; + __isset = other289.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -6693,21 +6717,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other289) { - maxColLen = other289.maxColLen; - avgColLen = other289.avgColLen; - numNulls = other289.numNulls; - numDVs = other289.numDVs; - bitVectors = other289.bitVectors; - __isset = other289.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other290) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other290) { maxColLen = other290.maxColLen; avgColLen = other290.avgColLen; numNulls = other290.numNulls; numDVs = other290.numDVs; bitVectors = other290.bitVectors; __isset = other290.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other291) { + maxColLen = other291.maxColLen; + avgColLen = other291.avgColLen; + numNulls = other291.numNulls; + numDVs = other291.numDVs; + bitVectors = other291.bitVectors; + __isset = other291.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -6853,19 +6877,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other291) { - maxColLen = other291.maxColLen; - avgColLen = other291.avgColLen; - numNulls = other291.numNulls; - bitVectors = other291.bitVectors; - __isset = other291.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other292) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other292) { maxColLen = other292.maxColLen; avgColLen = other292.avgColLen; numNulls = other292.numNulls; bitVectors = other292.bitVectors; __isset = other292.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other293) { + maxColLen = other293.maxColLen; + avgColLen = other293.avgColLen; + numNulls = other293.numNulls; + bitVectors = other293.bitVectors; + __isset = other293.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -6970,13 +6994,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other293) { - unscaled = other293.unscaled; - scale = other293.scale; -} -Decimal& Decimal::operator=(const Decimal& other294) { +Decimal::Decimal(const Decimal& other294) { unscaled = other294.unscaled; scale = other294.scale; +} +Decimal& Decimal::operator=(const Decimal& other295) { + unscaled = other295.unscaled; + scale = other295.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7137,21 +7161,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other295) { - lowValue = other295.lowValue; - highValue = other295.highValue; - numNulls = other295.numNulls; - numDVs = other295.numDVs; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other296) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other296) { lowValue = other296.lowValue; highValue = other296.highValue; numNulls = other296.numNulls; numDVs = other296.numDVs; bitVectors = other296.bitVectors; __isset = other296.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other297) { + lowValue = other297.lowValue; + highValue = other297.highValue; + numNulls = other297.numNulls; + numDVs = other297.numDVs; + bitVectors = other297.bitVectors; + __isset = other297.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7237,11 +7261,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other297) { - daysSinceEpoch = other297.daysSinceEpoch; -} -Date& Date::operator=(const Date& other298) { +Date::Date(const Date& other298) { daysSinceEpoch = other298.daysSinceEpoch; +} +Date& Date::operator=(const Date& other299) { + daysSinceEpoch = other299.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7401,21 +7425,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other300) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other300) { lowValue = other300.lowValue; highValue = other300.highValue; numNulls = other300.numNulls; numDVs = other300.numDVs; bitVectors = other300.bitVectors; __isset = other300.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other301) { + lowValue = other301.lowValue; + highValue = other301.highValue; + numNulls = other301.numNulls; + numDVs = other301.numDVs; + bitVectors = other301.bitVectors; + __isset = other301.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -7601,17 +7625,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other301) { - booleanStats = other301.booleanStats; - longStats = other301.longStats; - doubleStats = other301.doubleStats; - stringStats = other301.stringStats; - binaryStats = other301.binaryStats; - decimalStats = other301.decimalStats; - dateStats = other301.dateStats; - __isset = other301.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other302) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other302) { booleanStats = other302.booleanStats; longStats = other302.longStats; doubleStats = other302.doubleStats; @@ -7620,6 +7634,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData decimalStats = other302.decimalStats; dateStats = other302.dateStats; __isset = other302.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other303) { + booleanStats = other303.booleanStats; + longStats = other303.longStats; + doubleStats = other303.doubleStats; + stringStats = other303.stringStats; + binaryStats = other303.binaryStats; + decimalStats = other303.decimalStats; + dateStats = other303.dateStats; + __isset = other303.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -7747,15 +7771,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other303) { - colName = other303.colName; - colType = other303.colType; - statsData = other303.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other304) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other304) { colName = other304.colName; colType = other304.colType; statsData = other304.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other305) { + colName = other305.colName; + colType = other305.colType; + statsData = other305.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -7918,21 +7942,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other305) { - isTblLevel = other305.isTblLevel; - dbName = other305.dbName; - tableName = other305.tableName; - partName = other305.partName; - lastAnalyzed = other305.lastAnalyzed; - __isset = other305.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other306) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other306) { isTblLevel = other306.isTblLevel; dbName = other306.dbName; tableName = other306.tableName; partName = other306.partName; lastAnalyzed = other306.lastAnalyzed; __isset = other306.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other307) { + isTblLevel = other307.isTblLevel; + dbName = other307.dbName; + tableName = other307.tableName; + partName = other307.partName; + lastAnalyzed = other307.lastAnalyzed; + __isset = other307.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -7994,14 +8018,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size307; - ::apache::thrift::protocol::TType _etype310; - xfer += iprot->readListBegin(_etype310, _size307); - this->statsObj.resize(_size307); - uint32_t _i311; - for (_i311 = 0; _i311 < _size307; ++_i311) + uint32_t _size308; + ::apache::thrift::protocol::TType _etype311; + xfer += iprot->readListBegin(_etype311, _size308); + this->statsObj.resize(_size308); + uint32_t _i312; + for (_i312 = 0; _i312 < _size308; ++_i312) { - xfer += this->statsObj[_i311].read(iprot); + xfer += this->statsObj[_i312].read(iprot); } xfer += iprot->readListEnd(); } @@ -8038,10 +8062,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c 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 _iter312; - for (_iter312 = this->statsObj.begin(); _iter312 != this->statsObj.end(); ++_iter312) + std::vector<ColumnStatisticsObj> ::const_iterator _iter313; + for (_iter313 = this->statsObj.begin(); _iter313 != this->statsObj.end(); ++_iter313) { - xfer += (*_iter312).write(oprot); + xfer += (*_iter313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8058,13 +8082,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other313) { - statsDesc = other313.statsDesc; - statsObj = other313.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other314) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other314) { statsDesc = other314.statsDesc; statsObj = other314.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other315) { + statsDesc = other315.statsDesc; + statsObj = other315.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8115,14 +8139,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size315; - ::apache::thrift::protocol::TType _etype318; - xfer += iprot->readListBegin(_etype318, _size315); - this->colStats.resize(_size315); - uint32_t _i319; - for (_i319 = 0; _i319 < _size315; ++_i319) + uint32_t _size316; + ::apache::thrift::protocol::TType _etype319; + xfer += iprot->readListBegin(_etype319, _size316); + this->colStats.resize(_size316); + uint32_t _i320; + for (_i320 = 0; _i320 < _size316; ++_i320) { - xfer += this->colStats[_i319].read(iprot); + xfer += this->colStats[_i320].read(iprot); } xfer += iprot->readListEnd(); } @@ -8163,10 +8187,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter320; - for (_iter320 = this->colStats.begin(); _iter320 != this->colStats.end(); ++_iter320) + std::vector<ColumnStatisticsObj> ::const_iterator _iter321; + for (_iter321 = this->colStats.begin(); _iter321 != this->colStats.end(); ++_iter321) { - xfer += (*_iter320).write(oprot); + xfer += (*_iter321).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8187,13 +8211,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other321) { - colStats = other321.colStats; - partsFound = other321.partsFound; -} -AggrStats& AggrStats::operator=(const AggrStats& other322) { +AggrStats::AggrStats(const AggrStats& other322) { colStats = other322.colStats; partsFound = other322.partsFound; +} +AggrStats& AggrStats::operator=(const AggrStats& other323) { + colStats = other323.colStats; + partsFound = other323.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8244,14 +8268,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size323; - ::apache::thrift::protocol::TType _etype326; - xfer += iprot->readListBegin(_etype326, _size323); - this->colStats.resize(_size323); - uint32_t _i327; - for (_i327 = 0; _i327 < _size323; ++_i327) + uint32_t _size324; + ::apache::thrift::protocol::TType _etype327; + xfer += iprot->readListBegin(_etype327, _size324); + this->colStats.resize(_size324); + uint32_t _i328; + for (_i328 = 0; _i328 < _size324; ++_i328) { - xfer += this->colStats[_i327].read(iprot); + xfer += this->colStats[_i328].read(iprot); } xfer += iprot->readListEnd(); } @@ -8290,10 +8314,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* 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 _iter328; - for (_iter328 = this->colStats.begin(); _iter328 != this->colStats.end(); ++_iter328) + std::vector<ColumnStatistics> ::const_iterator _iter329; + for (_iter329 = this->colStats.begin(); _iter329 != this->colStats.end(); ++_iter329) { - xfer += (*_iter328).write(oprot); + xfer += (*_iter329).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8316,15 +8340,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other329) { - colStats = other329.colStats; - needMerge = other329.needMerge; - __isset = other329.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other330) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other330) { colStats = other330.colStats; needMerge = other330.needMerge; __isset = other330.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other331) { + colStats = other331.colStats; + needMerge = other331.needMerge; + __isset = other331.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8373,14 +8397,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size331; - ::apache::thrift::protocol::TType _etype334; - xfer += iprot->readListBegin(_etype334, _size331); - this->fieldSchemas.resize(_size331); - uint32_t _i335; - for (_i335 = 0; _i335 < _size331; ++_i335) + uint32_t _size332; + ::apache::thrift::protocol::TType _etype335; + xfer += iprot->readListBegin(_etype335, _size332); + this->fieldSchemas.resize(_size332); + uint32_t _i336; + for (_i336 = 0; _i336 < _size332; ++_i336) { - xfer += this->fieldSchemas[_i335].read(iprot); + xfer += this->fieldSchemas[_i336].read(iprot); } xfer += iprot->readListEnd(); } @@ -8393,17 +8417,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size336; - ::apache::thrift::protocol::TType _ktype337; - ::apache::thrift::protocol::TType _vtype338; - xfer += iprot->readMapBegin(_ktype337, _vtype338, _size336); - uint32_t _i340; - for (_i340 = 0; _i340 < _size336; ++_i340) + uint32_t _size337; + ::apache::thrift::protocol::TType _ktype338; + ::apache::thrift::protocol::TType _vtype339; + xfer += iprot->readMapBegin(_ktype338, _vtype339, _size337); + uint32_t _i341; + for (_i341 = 0; _i341 < _size337; ++_i341) { - std::string _key341; - xfer += iprot->readString(_key341); - std::string& _val342 = this->properties[_key341]; - xfer += iprot->readString(_val342); + std::string _key342; + xfer += iprot->readString(_key342); + std::string& _val343 = this->properties[_key342]; + xfer += iprot->readString(_val343); } xfer += iprot->readMapEnd(); } @@ -8432,10 +8456,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter343; - for (_iter343 = this->fieldSchemas.begin(); _iter343 != this->fieldSchemas.end(); ++_iter343) + std::vector<FieldSchema> ::const_iterator _iter344; + for (_iter344 = this->fieldSchemas.begin(); _iter344 != this->fieldSchemas.end(); ++_iter344) { - xfer += (*_iter343).write(oprot); + xfer += (*_iter344).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8444,11 +8468,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { 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 _iter344; - for (_iter344 = this->properties.begin(); _iter344 != this->properties.end(); ++_iter344) + std::map<std::string, std::string> ::const_iterator _iter345; + for (_iter345 = this->properties.begin(); _iter345 != this->properties.end(); ++_iter345) { - xfer += oprot->writeString(_iter344->first); - xfer += oprot->writeString(_iter344->second); + xfer += oprot->writeString(_iter345->first); + xfer += oprot->writeString(_iter345->second); } xfer += oprot->writeMapEnd(); } @@ -8466,15 +8490,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other345) { - fieldSchemas = other345.fieldSchemas; - properties = other345.properties; - __isset = other345.__isset; -} -Schema& Schema::operator=(const Schema& other346) { +Schema::Schema(const Schema& other346) { fieldSchemas = other346.fieldSchemas; properties = other346.properties; __isset = other346.__isset; +} +Schema& Schema::operator=(const Schema& other347) { + fieldSchemas = other347.fieldSchemas; + properties = other347.properties; + __isset = other347.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8519,17 +8543,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size347; - ::apache::thrift::protocol::TType _ktype348; - ::apache::thrift::protocol::TType _vtype349; - xfer += iprot->readMapBegin(_ktype348, _vtype349, _size347); - uint32_t _i351; - for (_i351 = 0; _i351 < _size347; ++_i351) + uint32_t _size348; + ::apache::thrift::protocol::TType _ktype349; + ::apache::thrift::protocol::TType _vtype350; + xfer += iprot->readMapBegin(_ktype349, _vtype350, _size348); + uint32_t _i352; + for (_i352 = 0; _i352 < _size348; ++_i352) { - std::string _key352; - xfer += iprot->readString(_key352); - std::string& _val353 = this->properties[_key352]; - xfer += iprot->readString(_val353); + std::string _key353; + xfer += iprot->readString(_key353); + std::string& _val354 = this->properties[_key353]; + xfer += iprot->readString(_val354); } xfer += iprot->readMapEnd(); } @@ -8558,11 +8582,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot) 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 _iter354; - for (_iter354 = this->properties.begin(); _iter354 != this->properties.end(); ++_iter354) + std::map<std::string, std::string> ::const_iterator _iter355; + for (_iter355 = this->properties.begin(); _iter355 != this->properties.end(); ++_iter355) { - xfer += oprot->writeString(_iter354->first); - xfer += oprot->writeString(_iter354->second); + xfer += oprot->writeString(_iter355->first); + xfer += oprot->writeString(_iter355->second); } xfer += oprot->writeMapEnd(); } @@ -8579,13 +8603,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other355) { - properties = other355.properties; - __isset = other355.__isset; -} -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other356) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other356) { properties = other356.properties; __isset = other356.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other357) { + properties = other357.properties; + __isset = other357.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -8687,13 +8711,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other357) { - db_name = other357.db_name; - tbl_name = other357.tbl_name; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other358) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other358) { db_name = other358.db_name; tbl_name = other358.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other359) { + db_name = other359.db_name; + tbl_name = other359.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -8739,14 +8763,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _etype362; - xfer += iprot->readListBegin(_etype362, _size359); - this->primaryKeys.resize(_size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + uint32_t _size360; + ::apache::thrift::protocol::TType _etype363; + xfer += iprot->readListBegin(_etype363, _size360); + this->primaryKeys.resize(_size360); + uint32_t _i364; + for (_i364 = 0; _i364 < _size360; ++_i364) { - xfer += this->primaryKeys[_i363].read(iprot); + xfer += this->primaryKeys[_i364].read(iprot); } xfer += iprot->readListEnd(); } @@ -8777,10 +8801,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter364; - for (_iter364 = this->primaryKeys.begin(); _iter364 != this->primaryKeys.end(); ++_iter364) + std::vector<SQLPrimaryKey> ::const_iterator _iter365; + for (_iter365 = this->primaryKeys.begin(); _iter365 != this->primaryKeys.end(); ++_iter365) { - xfer += (*_iter364).write(oprot); + xfer += (*_iter365).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8796,11 +8820,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other365) { - primaryKeys = other365.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other366) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other366) { primaryKeys = other366.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other367) { + primaryKeys = other367.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -8931,19 +8955,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other367) { - parent_db_name = other367.parent_db_name; - parent_tbl_name = other367.parent_tbl_name; - foreign_db_name = other367.foreign_db_name; - foreign_tbl_name = other367.foreign_tbl_name; - __isset = other367.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other368) { +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other368) { parent_db_name = other368.parent_db_name; parent_tbl_name = other368.parent_tbl_name; foreign_db_name = other368.foreign_db_name; foreign_tbl_name = other368.foreign_tbl_name; __isset = other368.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other369) { + parent_db_name = other369.parent_db_name; + parent_tbl_name = other369.parent_tbl_name; + foreign_db_name = other369.foreign_db_name; + foreign_tbl_name = other369.foreign_tbl_name; + __isset = other369.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -8991,14 +9015,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size369; - ::apache::thrift::protocol::TType _etype372; - xfer += iprot->readListBegin(_etype372, _size369); - this->foreignKeys.resize(_size369); - uint32_t _i373; - for (_i373 = 0; _i373 < _size369; ++_i373) + uint32_t _size370; + ::apache::thrift::protocol::TType _etype373; + xfer += iprot->readListBegin(_etype373, _size370); + this->foreignKeys.resize(_size370); + uint32_t _i374; + for (_i374 = 0; _i374 < _size370; ++_i374) { - xfer += this->foreignKeys[_i373].read(iprot); + xfer += this->foreignKeys[_i374].read(iprot); } xfer += iprot->readListEnd(); } @@ -9029,10 +9053,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter374; - for (_iter374 = this->foreignKeys.begin(); _iter374 != this->foreignKeys.end(); ++_iter374) + std::vector<SQLForeignKey> ::const_iterator _iter375; + for (_iter375 = this->foreignKeys.begin(); _iter375 != this->foreignKeys.end(); ++_iter375) { - xfer += (*_iter374).write(oprot); + xfer += (*_iter375).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9048,11 +9072,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other375) { - foreignKeys = other375.foreignKeys; -} -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other376) { +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other376) { foreignKeys = other376.foreignKeys; +} +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other377) { + foreignKeys = other377.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9174,15 +9198,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other377) { - dbname = other377.dbname; - tablename = other377.tablename; - constraintname = other377.constraintname; -} -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other378) { +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other378) { dbname = other378.dbname; tablename = other378.tablename; constraintname = other378.constraintname; +} +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other379) { + dbname = other379.dbname; + tablename = other379.tablename; + constraintname = other379.constraintname; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -9229,14 +9253,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size379; - ::apache::thrift::protocol::TType _etype382; - xfer += iprot->readListBegin(_etype382, _size379); - this->primaryKeyCols.resize(_size379); - uint32_t _i383; - for (_i383 = 0; _i383 < _size379; ++_i383) + uint32_t _size380; + ::apache::thrift::protocol::TType _etype383; + xfer += iprot->readListBegin(_etype383, _size380); + this->primaryKeyCols.resize(_size380); + uint32_t _i384; + for (_i384 = 0; _i384 < _size380; ++_i384) { - xfer += this->primaryKeyCols[_i383].read(iprot); + xfer += this->primaryKeyCols[_i384].read(iprot); } xfer += iprot->readListEnd(); } @@ -9267,10 +9291,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeyCols.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter384; - for (_iter384 = this->primaryKeyCols.begin(); _iter384 != this->primaryKeyCols.end(); ++_iter384) + std::vector<SQLPrimaryKey> ::const_iterator _iter385; + for (_iter385 = this->primaryKeyCols.begin(); _iter385 != this->primaryKeyCols.end(); ++_iter385) { - xfer += (*_iter384).write(oprot); + xfer += (*_iter385).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9286,11 +9310,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other385) { - primaryKeyCols = other385.primaryKeyCols; -} -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other386) { +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other386) { primaryKeyCols = other386.primaryKeyCols; +} +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other387) { + primaryKeyCols = other387.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -9335,14 +9359,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size387; - ::apache::thrift::protocol::TType _etype390; - xfer += iprot->readListBegin(_etype390, _size387); - this->foreignKeyCols.resize(_size387); - uint32_t _i391; - for (_i391 = 0; _i391 < _size387; ++_i391) + uint32_t _size388; + ::apache::thrift::protocol::TType _etype391; + xfer += iprot->readListBegin(_etype391, _size388); + this->foreignKeyCols.resize(_size388); + uint32_t _i392; + for (_i392 = 0; _i392 < _size388; ++_i392) { - xfer += this->foreignKeyCols[_i391].read(iprot); + xfer += this->foreignKeyCols[_i392].read(iprot); } xfer += iprot->readListEnd(); } @@ -9373,10 +9397,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeyCols.size())); - std::vector<SQLForeignKey> ::const_iterator _iter392; - for (_iter392 = this->foreignKeyCols.begin(); _iter392 != this->foreignKeyCols.end(); ++_iter392) + std::vector<SQLForeignKey> ::const_iterator _iter393; + for (_iter393 = this->foreignKeyCols.begin(); _iter393 != this->foreignKeyCols.end(); ++_iter393) { - xfer += (*_iter392).write(oprot); + xfer += (*_iter393).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9392,11 +9416,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other393) { - foreignKeyCols = other393.foreignKeyCols; -} -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other394) { +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other394) { foreignKeyCols = other394.foreignKeyCols; +} +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other395) { + foreignKeyCols = other395.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -9446,14 +9470,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size395; - ::apache::thrift::protocol::TType _etype398; - xfer += iprot->readListBegin(_etype398, _size395); - this->partitions.resize(_size395); - uint32_t _i399; - for (_i399 = 0; _i399 < _size395; ++_i399) + uint32_t _size396; + ::apache::thrift::protocol::TType _etype399; + xfer += iprot->readListBegin(_etype399, _size396); + this->partitions.resize(_size396); + uint32_t _i400; + for (_i400 = 0; _i400 < _size396; ++_i400) { - xfer += this->partitions[_i399].read(iprot); + xfer += this->partitions[_i400].read(iprot); } xfer += iprot->readListEnd(); } @@ -9494,10 +9518,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op 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 _iter400; - for (_iter400 = this->partitions.begin(); _iter400 != this->partitions.end(); ++_iter400) + std::vector<Partition> ::const_iterator _iter401; + for (_iter401 = this->partitions.begin(); _iter401 != this->partitions.end(); ++_iter401) { - xfer += (*_iter400).write(oprot); + xfer += (*_iter401).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9518,13 +9542,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other401) { - partitions = other401.partitions; - hasUnknownPartitions = other401.hasUnknownPartitions; -} -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other402) { +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other402) { partitions = other402.partitions; hasUnknownPartitions = other402.hasUnknownPartitions; +} +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other403) { + partitions = other403.partitions; + hasUnknownPartitions = other403.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -9686,21 +9710,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other403) { - dbName = other403.dbName; - tblName = other403.tblName; - expr = other403.expr; - defaultPartitionName = other403.defaultPartitionName; - maxParts = other403.maxParts; - __isset = other403.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other404) { +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other404) { dbName = other404.dbName; tblName = other404.tblName; expr = other404.expr; defaultPartitionName = other404.defaultPartitionName; maxParts = other404.maxParts; __isset = other404.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other405) { + dbName = other405.dbName; + tblName = other405.tblName; + expr = other405.expr; + defaultPartitionName = other405.defaultPartitionName; + maxParts = other405.maxParts; + __isset = other405.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -9749,14 +9773,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size405; - ::apache::thrift::protocol::TType _etype408; - xfer += iprot->readListBegin(_etype408, _size405); - this->tableStats.resize(_size405); - uint32_t _i409; - for (_i409 = 0; _i409 < _size405; ++_i409) + uint32_t _size406; + ::apache::thrift::protocol::TType _etype409; + xfer += iprot->readListBegin(_etype409, _size406); + this->tableStats.resize(_size406); + uint32_t _i410; + for (_i410 = 0; _i410 < _size406; ++_i410) { - xfer += this->tableStats[_i409].read(iprot); + xfer += this->tableStats[_i410].read(iprot); } xfer += iprot->readListEnd(); } @@ -9787,10 +9811,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c 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 _iter410; - for (_iter410 = this->tableStats.begin(); _iter410 != this->tableStats.end(); ++_iter410) + std::vector<ColumnStatisticsObj> ::const_iterator _iter411; + for (_iter411 = this->tableStats.begin(); _iter411 != this->tableStats.end(); ++_iter411) { - xfer += (*_iter410).write(oprot); + xfer += (*_iter411).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9806,11 +9830,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other411) { - tableStats = other411.tableStats; -} -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other412) { +TableStatsResult::TableStatsResult(const TableStatsResult& other412) { tableStats = other412.tableStats; +} +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other413) { + tableStats = other413.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -9855,26 +9879,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size413; - ::apache::thrift::protocol::TType _ktype414; - ::apache::thrift::protocol::TType _vtype415; - xfer += iprot->readMapBegin(_ktype414, _vtype415, _size413); - uint32_t _i417; - for (_i417 = 0; _i417 < _size413; ++_i417) + uint32_t _size414; + ::apache::thrift::protocol::TType _ktype415; + ::apache::thrift::protocol::TType _vtype416; + xfer += iprot->readMapBegin(_ktype415, _vtype416, _size414); + uint32_t _i418; + for (_i418 = 0; _i418 < _size414; ++_i418) { - std::string _key418; - xfer += iprot->readString(_key418); - std::vector<ColumnStatisticsObj> & _val419 = this->partStats[_key418]; + std::string _key419; + xfer += iprot->readString(_key419); + std::vector<ColumnStatisticsObj> & _val420 = this->partStats[_key419]; { - _val419.clear(); - uint32_t _size420; - ::apache::thrift::protocol::TType _etype423; - xfer += iprot->readListBegin(_etype423, _size420); - _val419.resize(_size420); - uint32_t _i424; - for (_i424 = 0; _i424 < _size420; ++_i424) + _val420.clear(); + uint32_t _size421; + ::apache::thrift::protocol::TType _etype424; + xfer += iprot->readListBegin(_etype424, _size421); + _val420.resize(_size421); + uint32_t _i425; + for (_i425 = 0; _i425 < _size421; ++_i425) { - xfer += _val419[_i424].read(iprot); + xfer += _val420[_i425].read(iprot); } xfer += iprot->readListEnd(); } @@ -9908,16 +9932,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr 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 _iter425; - for (_iter425 = this->partStats.begin(); _iter425 != this->partStats.end(); ++_iter425) + std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter426; + for (_iter426 = this->partStats.begin(); _iter426 != this->partStats.end(); ++_iter426) { - xfer += oprot->writeString(_iter425->first); + xfer += oprot->writeString(_iter426->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter425->second.size())); - std::vector<ColumnStatisticsObj> ::const_iterator _iter426; - for (_iter426 = _iter425->second.begin(); _iter426 != _iter425->second.end(); ++_iter426) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter426->second.size())); + std::vector<ColumnStatisticsObj> ::const_iterator _iter427; + for (_iter427 = _iter426->second.begin(); _iter427 != _iter426->second.end(); ++_iter427) { - xfer += (*_iter426).write(oprot); + xfer += (*_iter427).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9936,11 +9960,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other427) { - partStats = other427.partStats; -} -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other428) { +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other428) { partStats = other428.partStats; +} +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other429) { + partStats = other429.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -10011,14 +10035,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size429; - ::apache::thrift::protocol::TType _etype432; - xfer += iprot->readListBegin(_etype432, _size429); - this->colNames.resize(_size429); - uint32_t _i433; - for (_i433 = 0; _i433 < _size429; ++_i433) + uint32_t _size430; + ::apache::thrift::protocol::TType _etype433; + xfer += iprot->readListBegin(_etype433, _size430); + this->colNames.resize(_size430); + uint32_t _i434; + for (_i434 = 0; _i434 < _size430; ++_i434) { - xfer += iprot->readString(this->colNames[_i433]); + xfer += iprot->readString(this->colNames[_i434]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10085,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) 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 _iter434; - for (_iter434 = this->colNames.begin(); _iter434 != this->colNames.end(); ++_iter434) + std::vector<std::string> ::const_iterator _iter435; + for (_iter435 = this->colNames.begin(); _iter435 != this->colNames.end(); ++_iter435) { - xfer += oprot->writeString((*_iter434)); + xfer += oprot->writeString((*_iter435)); } xfer += oprot->writeListEnd(); } @@ -10082,15 +10106,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.colNames, b.colNames); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other435) { - dbName = other435.dbName; - tblName = other435.tblName; - colNames = other435.colNames; -} -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other436) { +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other436) { dbName = other436.dbName; tblName = other436.tblName; colNames = other436.colNames; +} +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other437) { + dbName = other437.dbName; + tblName = other437.tblName; + colNames = other437.colNames; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -10168,14 +10192,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size437; - ::apache::thrift::protocol::TType _etype440; - xfer += iprot->readListBegin(_etype440, _size437); - this->colNames.resize(_size437); - uint32_t _i441; - for (_i441 = 0; _i441 < _size437; ++_i441) + uint32_t _size438; + ::apache::thrift::protocol::TType _etype441; + xfer += iprot->readListBegin(_etype441, _size438); + this->colNames.resize(_size438); + uint32_t _i442; + for (_i442 = 0; _i442 < _size438; ++_i442) { - xfer += iprot->readString(this->colNames[_i441]); + xfer += iprot->readString(this->colNames[_i442]); } xfer += iprot->readListEnd(); } @@ -10188,14 +10212,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size442; - ::apache::thrift::protocol::TType _etype445; - xfer += iprot->readListBegin(_etype445, _size442); - this->partNames.resize(_size442); - uint32_t _i446; - for (_i446 = 0; _i446 < _size442; ++_i446) + uint32_t _size443; + ::apache::thrift::protocol::TType _etype446; + xfer += iprot->readListBegin(_etype446, _size443); + this->partNames.resize(_size443); + uint32_t _i447; + for (_i447 = 0; _i447 < _size443; ++_i447) { - xfer += iprot->readString(this->partNames[_i446]); + xfer += iprot->readString(this->partNames[_i447]); } xfer += iprot->readListEnd(); } @@ -10240,10 +10264,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op 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 _iter447; - for (_iter447 = this->colNames.begin(); _iter447 != this->colNames.end(); ++_iter447) + std::vector<std::string> ::const_iterator _iter448; + for (_iter448 = this->colNames.begin(); _iter448 != this->colNames.end(); ++_iter448) { - xfer += oprot->writeString((*_iter447)); + xfer += oprot->writeString((*_iter448)); } xfer += oprot->writeListEnd(); } @@ -10252,10 +10276,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op 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 _iter448; - for (_iter448 = this->partNames.begin(); _iter448 != this->partNames.end(); ++_iter448) + std::vector<std::string> ::const_iterator _iter449; + for (_iter449 = this->partNames.begin(); _iter449 != this->partNames.end(); ++_iter449) { - xfer += oprot->writeString((*_iter448)); + xfer += oprot->writeString((*_iter449)); } xfer += oprot->writeListEnd(); } @@ -10274,17 +10298,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.partNames, b.partNames); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other449) { - dbName = other449.dbName; - tblName = other449.tblName; - colNames = other449.colNames; - partNames = other449.partNames; -} -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other450) { +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other450) { dbName = other450.dbName; tblName = other450.tblName; colNames = other450.colNames; partNames = other450.partNames; +} +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other451) { + dbName = other451.dbName; + tblName = other451.tblName; + colNames = other451.colNames; + partNames = other451.partNames; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -10332,14 +10356,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size451; - ::apache::thrift::protocol::TType _etype454; - xfer += iprot->readListBegin(_etype454, _size451); - this->partitions.resize(_size451); - uint32_t _i455; - for (_i455 = 0; _i455 < _size451; ++_i455) + uint32_t _size452; + ::apache::thrift::protocol::TType _etype455; + xfer += iprot->readListBegin(_etype455, _size452); + this->partitions.resize(_size452); + uint32_t _i456; + for (_i456 = 0; _i456 < _size452; ++_i456) { - xfer += this->partitions[_i455].read(iprot); + xfer += this->partitions[_i456].read(iprot); } xfer += iprot->readListEnd(); } @@ -10369,10 +10393,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot 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 _iter456; - for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456) + std::vector<Partition> ::const_iterator _iter457; + for (_iter457 = this->partitions.begin(); _iter457 != this->partitions.end(); ++_iter457) { - xfer += (*_iter456).write(oprot); + xfer += (*_iter457).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10389,13 +10413,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other457) { - partitions = other457.partitions; - __isset = other457.__isset; -} -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other458) { +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other458) { partitions = other458.partitions; __isset = other458.__isset; +} +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other459) { + partitions = other459.partitions; + __isset = other459.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -10476,14 +10500,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size459; - ::apache::thrift::protocol::TType _etype462; - xfer += iprot->readListBegin(_etype462, _size459); - this->parts.resize(_size459); - uint32_t _i463; - for (_i463 = 0; _i463 < _size459; ++_i463) + uint32_t _size460; + ::apache::thrift::protocol::TType _etype463; + xfer += iprot->readListBegin(_etype463, _size460); + this->parts.resize(_size460); + uint32_t _i464; + for (_i464 = 0; _i464 < _size460; ++_i464) { - xfer += this->parts[_i463].read(iprot); + xfer += this->parts[_i464].read(iprot); } xfer += iprot->readListEnd(); } @@ -10544,10 +10568,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro 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 _iter464; - for (_iter464 = this->parts.begin(); _iter464 != this->parts.end(); ++_iter464) + std::vector<Partition> ::const_iterator _iter465;
<TRUNCATED>
