http://git-wip-us.apache.org/repos/asf/hive/blob/6e9b63e4/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index aadf8f1..2169265 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -149,6 +149,18 @@ const char* _kEventRequestTypeNames[] = { }; const std::map<int, const char*> _EventRequestType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kEventRequestTypeValues, _kEventRequestTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +int _kBucketingVersionValues[] = { + BucketingVersion::INVALID_BUCKETING, + BucketingVersion::JAVA_BUCKETING, + BucketingVersion::MURMUR_BUCKETING +}; +const char* _kBucketingVersionNames[] = { + "INVALID_BUCKETING", + "JAVA_BUCKETING", + "MURMUR_BUCKETING" +}; +const std::map<int, const char*> _BucketingVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kBucketingVersionValues, _kBucketingVersionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + int _kFunctionTypeValues[] = { FunctionType::JAVA }; @@ -4945,6 +4957,16 @@ void Table::__set_creationMetadata(const CreationMetadata& val) { __isset.creationMetadata = true; } +void Table::__set_bucketingVersion(const BucketingVersion::type val) { + this->bucketingVersion = val; +__isset.bucketingVersion = true; +} + +void Table::__set_loadInBucketedTable(const bool val) { + this->loadInBucketedTable = val; +__isset.loadInBucketedTable = true; +} + uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -5121,6 +5143,24 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 17: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast223; + xfer += iprot->readI32(ecast223); + this->bucketingVersion = (BucketingVersion::type)ecast223; + this->__isset.bucketingVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 18: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->loadInBucketedTable); + this->__isset.loadInBucketedTable = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -5169,10 +5209,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 _iter223; - for (_iter223 = this->partitionKeys.begin(); _iter223 != this->partitionKeys.end(); ++_iter223) + std::vector<FieldSchema> ::const_iterator _iter224; + for (_iter224 = this->partitionKeys.begin(); _iter224 != this->partitionKeys.end(); ++_iter224) { - xfer += (*_iter223).write(oprot); + xfer += (*_iter224).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5181,11 +5221,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 _iter224; - for (_iter224 = this->parameters.begin(); _iter224 != this->parameters.end(); ++_iter224) + std::map<std::string, std::string> ::const_iterator _iter225; + for (_iter225 = this->parameters.begin(); _iter225 != this->parameters.end(); ++_iter225) { - xfer += oprot->writeString(_iter224->first); - xfer += oprot->writeString(_iter224->second); + xfer += oprot->writeString(_iter225->first); + xfer += oprot->writeString(_iter225->second); } xfer += oprot->writeMapEnd(); } @@ -5223,6 +5263,16 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += this->creationMetadata.write(oprot); xfer += oprot->writeFieldEnd(); } + if (this->__isset.bucketingVersion) { + xfer += oprot->writeFieldBegin("bucketingVersion", ::apache::thrift::protocol::T_I32, 17); + xfer += oprot->writeI32((int32_t)this->bucketingVersion); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.loadInBucketedTable) { + xfer += oprot->writeFieldBegin("loadInBucketedTable", ::apache::thrift::protocol::T_BOOL, 18); + xfer += oprot->writeBool(this->loadInBucketedTable); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -5246,29 +5296,12 @@ void swap(Table &a, Table &b) { swap(a.temporary, b.temporary); swap(a.rewriteEnabled, b.rewriteEnabled); swap(a.creationMetadata, b.creationMetadata); + swap(a.bucketingVersion, b.bucketingVersion); + swap(a.loadInBucketedTable, b.loadInBucketedTable); swap(a.__isset, b.__isset); } -Table::Table(const Table& other225) { - tableName = other225.tableName; - dbName = other225.dbName; - owner = other225.owner; - createTime = other225.createTime; - lastAccessTime = other225.lastAccessTime; - retention = other225.retention; - sd = other225.sd; - partitionKeys = other225.partitionKeys; - parameters = other225.parameters; - viewOriginalText = other225.viewOriginalText; - viewExpandedText = other225.viewExpandedText; - tableType = other225.tableType; - privileges = other225.privileges; - temporary = other225.temporary; - rewriteEnabled = other225.rewriteEnabled; - creationMetadata = other225.creationMetadata; - __isset = other225.__isset; -} -Table& Table::operator=(const Table& other226) { +Table::Table(const Table& other226) { tableName = other226.tableName; dbName = other226.dbName; owner = other226.owner; @@ -5285,7 +5318,30 @@ Table& Table::operator=(const Table& other226) { temporary = other226.temporary; rewriteEnabled = other226.rewriteEnabled; creationMetadata = other226.creationMetadata; + bucketingVersion = other226.bucketingVersion; + loadInBucketedTable = other226.loadInBucketedTable; __isset = other226.__isset; +} +Table& Table::operator=(const Table& other227) { + tableName = other227.tableName; + dbName = other227.dbName; + owner = other227.owner; + createTime = other227.createTime; + lastAccessTime = other227.lastAccessTime; + retention = other227.retention; + sd = other227.sd; + partitionKeys = other227.partitionKeys; + parameters = other227.parameters; + viewOriginalText = other227.viewOriginalText; + viewExpandedText = other227.viewExpandedText; + tableType = other227.tableType; + privileges = other227.privileges; + temporary = other227.temporary; + rewriteEnabled = other227.rewriteEnabled; + creationMetadata = other227.creationMetadata; + bucketingVersion = other227.bucketingVersion; + loadInBucketedTable = other227.loadInBucketedTable; + __isset = other227.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -5307,6 +5363,8 @@ void Table::printTo(std::ostream& out) const { out << ", " << "temporary="; (__isset.temporary ? (out << to_string(temporary)) : (out << "<null>")); out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "<null>")); out << ", " << "creationMetadata="; (__isset.creationMetadata ? (out << to_string(creationMetadata)) : (out << "<null>")); + out << ", " << "bucketingVersion="; (__isset.bucketingVersion ? (out << to_string(bucketingVersion)) : (out << "<null>")); + out << ", " << "loadInBucketedTable="; (__isset.loadInBucketedTable ? (out << to_string(loadInBucketedTable)) : (out << "<null>")); out << ")"; } @@ -5373,14 +5431,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size227; - ::apache::thrift::protocol::TType _etype230; - xfer += iprot->readListBegin(_etype230, _size227); - this->values.resize(_size227); - uint32_t _i231; - for (_i231 = 0; _i231 < _size227; ++_i231) + uint32_t _size228; + ::apache::thrift::protocol::TType _etype231; + xfer += iprot->readListBegin(_etype231, _size228); + this->values.resize(_size228); + uint32_t _i232; + for (_i232 = 0; _i232 < _size228; ++_i232) { - xfer += iprot->readString(this->values[_i231]); + xfer += iprot->readString(this->values[_i232]); } xfer += iprot->readListEnd(); } @@ -5433,17 +5491,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size232; - ::apache::thrift::protocol::TType _ktype233; - ::apache::thrift::protocol::TType _vtype234; - xfer += iprot->readMapBegin(_ktype233, _vtype234, _size232); - uint32_t _i236; - for (_i236 = 0; _i236 < _size232; ++_i236) + uint32_t _size233; + ::apache::thrift::protocol::TType _ktype234; + ::apache::thrift::protocol::TType _vtype235; + xfer += iprot->readMapBegin(_ktype234, _vtype235, _size233); + uint32_t _i237; + for (_i237 = 0; _i237 < _size233; ++_i237) { - std::string _key237; - xfer += iprot->readString(_key237); - std::string& _val238 = this->parameters[_key237]; - xfer += iprot->readString(_val238); + std::string _key238; + xfer += iprot->readString(_key238); + std::string& _val239 = this->parameters[_key238]; + xfer += iprot->readString(_val239); } xfer += iprot->readMapEnd(); } @@ -5480,10 +5538,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 _iter239; - for (_iter239 = this->values.begin(); _iter239 != this->values.end(); ++_iter239) + std::vector<std::string> ::const_iterator _iter240; + for (_iter240 = this->values.begin(); _iter240 != this->values.end(); ++_iter240) { - xfer += oprot->writeString((*_iter239)); + xfer += oprot->writeString((*_iter240)); } xfer += oprot->writeListEnd(); } @@ -5512,11 +5570,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 _iter240; - for (_iter240 = this->parameters.begin(); _iter240 != this->parameters.end(); ++_iter240) + std::map<std::string, std::string> ::const_iterator _iter241; + for (_iter241 = this->parameters.begin(); _iter241 != this->parameters.end(); ++_iter241) { - xfer += oprot->writeString(_iter240->first); - xfer += oprot->writeString(_iter240->second); + xfer += oprot->writeString(_iter241->first); + xfer += oprot->writeString(_iter241->second); } xfer += oprot->writeMapEnd(); } @@ -5545,18 +5603,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other241) { - values = other241.values; - dbName = other241.dbName; - tableName = other241.tableName; - createTime = other241.createTime; - lastAccessTime = other241.lastAccessTime; - sd = other241.sd; - parameters = other241.parameters; - privileges = other241.privileges; - __isset = other241.__isset; -} -Partition& Partition::operator=(const Partition& other242) { +Partition::Partition(const Partition& other242) { values = other242.values; dbName = other242.dbName; tableName = other242.tableName; @@ -5566,6 +5613,17 @@ Partition& Partition::operator=(const Partition& other242) { parameters = other242.parameters; privileges = other242.privileges; __isset = other242.__isset; +} +Partition& Partition::operator=(const Partition& other243) { + values = other243.values; + dbName = other243.dbName; + tableName = other243.tableName; + createTime = other243.createTime; + lastAccessTime = other243.lastAccessTime; + sd = other243.sd; + parameters = other243.parameters; + privileges = other243.privileges; + __isset = other243.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5637,14 +5695,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size243; - ::apache::thrift::protocol::TType _etype246; - xfer += iprot->readListBegin(_etype246, _size243); - this->values.resize(_size243); - uint32_t _i247; - for (_i247 = 0; _i247 < _size243; ++_i247) + uint32_t _size244; + ::apache::thrift::protocol::TType _etype247; + xfer += iprot->readListBegin(_etype247, _size244); + this->values.resize(_size244); + uint32_t _i248; + for (_i248 = 0; _i248 < _size244; ++_i248) { - xfer += iprot->readString(this->values[_i247]); + xfer += iprot->readString(this->values[_i248]); } xfer += iprot->readListEnd(); } @@ -5681,17 +5739,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size248; - ::apache::thrift::protocol::TType _ktype249; - ::apache::thrift::protocol::TType _vtype250; - xfer += iprot->readMapBegin(_ktype249, _vtype250, _size248); - uint32_t _i252; - for (_i252 = 0; _i252 < _size248; ++_i252) + uint32_t _size249; + ::apache::thrift::protocol::TType _ktype250; + ::apache::thrift::protocol::TType _vtype251; + xfer += iprot->readMapBegin(_ktype250, _vtype251, _size249); + uint32_t _i253; + for (_i253 = 0; _i253 < _size249; ++_i253) { - std::string _key253; - xfer += iprot->readString(_key253); - std::string& _val254 = this->parameters[_key253]; - xfer += iprot->readString(_val254); + std::string _key254; + xfer += iprot->readString(_key254); + std::string& _val255 = this->parameters[_key254]; + xfer += iprot->readString(_val255); } xfer += iprot->readMapEnd(); } @@ -5728,10 +5786,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 _iter255; - for (_iter255 = this->values.begin(); _iter255 != this->values.end(); ++_iter255) + std::vector<std::string> ::const_iterator _iter256; + for (_iter256 = this->values.begin(); _iter256 != this->values.end(); ++_iter256) { - xfer += oprot->writeString((*_iter255)); + xfer += oprot->writeString((*_iter256)); } xfer += oprot->writeListEnd(); } @@ -5752,11 +5810,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 _iter256; - for (_iter256 = this->parameters.begin(); _iter256 != this->parameters.end(); ++_iter256) + std::map<std::string, std::string> ::const_iterator _iter257; + for (_iter257 = this->parameters.begin(); _iter257 != this->parameters.end(); ++_iter257) { - xfer += oprot->writeString(_iter256->first); - xfer += oprot->writeString(_iter256->second); + xfer += oprot->writeString(_iter257->first); + xfer += oprot->writeString(_iter257->second); } xfer += oprot->writeMapEnd(); } @@ -5783,16 +5841,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other257) { - values = other257.values; - createTime = other257.createTime; - lastAccessTime = other257.lastAccessTime; - relativePath = other257.relativePath; - parameters = other257.parameters; - privileges = other257.privileges; - __isset = other257.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other258) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other258) { values = other258.values; createTime = other258.createTime; lastAccessTime = other258.lastAccessTime; @@ -5800,6 +5849,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other258.parameters; privileges = other258.privileges; __isset = other258.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other259) { + values = other259.values; + createTime = other259.createTime; + lastAccessTime = other259.lastAccessTime; + relativePath = other259.relativePath; + parameters = other259.parameters; + privileges = other259.privileges; + __isset = other259.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5852,14 +5910,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + uint32_t _size260; + ::apache::thrift::protocol::TType _etype263; + xfer += iprot->readListBegin(_etype263, _size260); + this->partitions.resize(_size260); + uint32_t _i264; + for (_i264 = 0; _i264 < _size260; ++_i264) { - xfer += this->partitions[_i263].read(iprot); + xfer += this->partitions[_i264].read(iprot); } xfer += iprot->readListEnd(); } @@ -5896,10 +5954,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 _iter264; - for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264) + std::vector<PartitionWithoutSD> ::const_iterator _iter265; + for (_iter265 = this->partitions.begin(); _iter265 != this->partitions.end(); ++_iter265) { - xfer += (*_iter264).write(oprot); + xfer += (*_iter265).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5921,15 +5979,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other265) { - partitions = other265.partitions; - sd = other265.sd; - __isset = other265.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other266) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other266) { partitions = other266.partitions; sd = other266.sd; __isset = other266.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other267) { + partitions = other267.partitions; + sd = other267.sd; + __isset = other267.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5974,14 +6032,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size267; - ::apache::thrift::protocol::TType _etype270; - xfer += iprot->readListBegin(_etype270, _size267); - this->partitions.resize(_size267); - uint32_t _i271; - for (_i271 = 0; _i271 < _size267; ++_i271) + uint32_t _size268; + ::apache::thrift::protocol::TType _etype271; + xfer += iprot->readListBegin(_etype271, _size268); + this->partitions.resize(_size268); + uint32_t _i272; + for (_i272 = 0; _i272 < _size268; ++_i272) { - xfer += this->partitions[_i271].read(iprot); + xfer += this->partitions[_i272].read(iprot); } xfer += iprot->readListEnd(); } @@ -6010,10 +6068,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 _iter272; - for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) + std::vector<Partition> ::const_iterator _iter273; + for (_iter273 = this->partitions.begin(); _iter273 != this->partitions.end(); ++_iter273) { - xfer += (*_iter272).write(oprot); + xfer += (*_iter273).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6030,13 +6088,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other273) { - partitions = other273.partitions; - __isset = other273.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other274) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other274) { partitions = other274.partitions; __isset = other274.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other275) { + partitions = other275.partitions; + __isset = other275.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -6188,21 +6246,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other275) { - dbName = other275.dbName; - tableName = other275.tableName; - rootPath = other275.rootPath; - sharedSDPartitionSpec = other275.sharedSDPartitionSpec; - partitionList = other275.partitionList; - __isset = other275.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other276) { +PartitionSpec::PartitionSpec(const PartitionSpec& other276) { dbName = other276.dbName; tableName = other276.tableName; rootPath = other276.rootPath; sharedSDPartitionSpec = other276.sharedSDPartitionSpec; partitionList = other276.partitionList; __isset = other276.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other277) { + dbName = other277.dbName; + tableName = other277.tableName; + rootPath = other277.rootPath; + sharedSDPartitionSpec = other277.sharedSDPartitionSpec; + partitionList = other277.partitionList; + __isset = other277.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -6350,17 +6408,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size277; - ::apache::thrift::protocol::TType _ktype278; - ::apache::thrift::protocol::TType _vtype279; - xfer += iprot->readMapBegin(_ktype278, _vtype279, _size277); - uint32_t _i281; - for (_i281 = 0; _i281 < _size277; ++_i281) + uint32_t _size278; + ::apache::thrift::protocol::TType _ktype279; + ::apache::thrift::protocol::TType _vtype280; + xfer += iprot->readMapBegin(_ktype279, _vtype280, _size278); + uint32_t _i282; + for (_i282 = 0; _i282 < _size278; ++_i282) { - std::string _key282; - xfer += iprot->readString(_key282); - std::string& _val283 = this->parameters[_key282]; - xfer += iprot->readString(_val283); + std::string _key283; + xfer += iprot->readString(_key283); + std::string& _val284 = this->parameters[_key283]; + xfer += iprot->readString(_val284); } xfer += iprot->readMapEnd(); } @@ -6429,11 +6487,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 _iter284; - for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284) + std::map<std::string, std::string> ::const_iterator _iter285; + for (_iter285 = this->parameters.begin(); _iter285 != this->parameters.end(); ++_iter285) { - xfer += oprot->writeString(_iter284->first); - xfer += oprot->writeString(_iter284->second); + xfer += oprot->writeString(_iter285->first); + xfer += oprot->writeString(_iter285->second); } xfer += oprot->writeMapEnd(); } @@ -6463,20 +6521,7 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other285) { - indexName = other285.indexName; - indexHandlerClass = other285.indexHandlerClass; - dbName = other285.dbName; - origTableName = other285.origTableName; - createTime = other285.createTime; - lastAccessTime = other285.lastAccessTime; - indexTableName = other285.indexTableName; - sd = other285.sd; - parameters = other285.parameters; - deferredRebuild = other285.deferredRebuild; - __isset = other285.__isset; -} -Index& Index::operator=(const Index& other286) { +Index::Index(const Index& other286) { indexName = other286.indexName; indexHandlerClass = other286.indexHandlerClass; dbName = other286.dbName; @@ -6488,6 +6533,19 @@ Index& Index::operator=(const Index& other286) { parameters = other286.parameters; deferredRebuild = other286.deferredRebuild; __isset = other286.__isset; +} +Index& Index::operator=(const Index& other287) { + indexName = other287.indexName; + indexHandlerClass = other287.indexHandlerClass; + dbName = other287.dbName; + origTableName = other287.origTableName; + createTime = other287.createTime; + lastAccessTime = other287.lastAccessTime; + indexTableName = other287.indexTableName; + sd = other287.sd; + parameters = other287.parameters; + deferredRebuild = other287.deferredRebuild; + __isset = other287.__isset; return *this; } void Index::printTo(std::ostream& out) const { @@ -6638,19 +6696,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other287) { - numTrues = other287.numTrues; - numFalses = other287.numFalses; - numNulls = other287.numNulls; - bitVectors = other287.bitVectors; - __isset = other287.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other288) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other288) { numTrues = other288.numTrues; numFalses = other288.numFalses; numNulls = other288.numNulls; bitVectors = other288.bitVectors; __isset = other288.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other289) { + numTrues = other289.numTrues; + numFalses = other289.numFalses; + numNulls = other289.numNulls; + bitVectors = other289.bitVectors; + __isset = other289.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6813,21 +6871,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other289) { - lowValue = other289.lowValue; - highValue = other289.highValue; - numNulls = other289.numNulls; - numDVs = other289.numDVs; - bitVectors = other289.bitVectors; - __isset = other289.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other290) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other290) { lowValue = other290.lowValue; highValue = other290.highValue; numNulls = other290.numNulls; numDVs = other290.numDVs; bitVectors = other290.bitVectors; __isset = other290.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other291) { + lowValue = other291.lowValue; + highValue = other291.highValue; + numNulls = other291.numNulls; + numDVs = other291.numDVs; + bitVectors = other291.bitVectors; + __isset = other291.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -6991,21 +7049,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other291) { - lowValue = other291.lowValue; - highValue = other291.highValue; - numNulls = other291.numNulls; - numDVs = other291.numDVs; - bitVectors = other291.bitVectors; - __isset = other291.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other292) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other292) { lowValue = other292.lowValue; highValue = other292.highValue; numNulls = other292.numNulls; numDVs = other292.numDVs; bitVectors = other292.bitVectors; __isset = other292.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other293) { + lowValue = other293.lowValue; + highValue = other293.highValue; + numNulls = other293.numNulls; + numDVs = other293.numDVs; + bitVectors = other293.bitVectors; + __isset = other293.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7171,21 +7229,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other293) { - maxColLen = other293.maxColLen; - avgColLen = other293.avgColLen; - numNulls = other293.numNulls; - numDVs = other293.numDVs; - bitVectors = other293.bitVectors; - __isset = other293.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other294) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other294) { maxColLen = other294.maxColLen; avgColLen = other294.avgColLen; numNulls = other294.numNulls; numDVs = other294.numDVs; bitVectors = other294.bitVectors; __isset = other294.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other295) { + maxColLen = other295.maxColLen; + avgColLen = other295.avgColLen; + numNulls = other295.numNulls; + numDVs = other295.numDVs; + bitVectors = other295.bitVectors; + __isset = other295.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7331,19 +7389,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other295) { - maxColLen = other295.maxColLen; - avgColLen = other295.avgColLen; - numNulls = other295.numNulls; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other296) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other296) { maxColLen = other296.maxColLen; avgColLen = other296.avgColLen; numNulls = other296.numNulls; bitVectors = other296.bitVectors; __isset = other296.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other297) { + maxColLen = other297.maxColLen; + avgColLen = other297.avgColLen; + numNulls = other297.numNulls; + bitVectors = other297.bitVectors; + __isset = other297.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7448,13 +7506,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other297) { - unscaled = other297.unscaled; - scale = other297.scale; -} -Decimal& Decimal::operator=(const Decimal& other298) { +Decimal::Decimal(const Decimal& other298) { unscaled = other298.unscaled; scale = other298.scale; +} +Decimal& Decimal::operator=(const Decimal& other299) { + unscaled = other299.unscaled; + scale = other299.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7615,21 +7673,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other300) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other300) { lowValue = other300.lowValue; highValue = other300.highValue; numNulls = other300.numNulls; numDVs = other300.numDVs; bitVectors = other300.bitVectors; __isset = other300.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other301) { + lowValue = other301.lowValue; + highValue = other301.highValue; + numNulls = other301.numNulls; + numDVs = other301.numDVs; + bitVectors = other301.bitVectors; + __isset = other301.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7715,11 +7773,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other301) { - daysSinceEpoch = other301.daysSinceEpoch; -} -Date& Date::operator=(const Date& other302) { +Date::Date(const Date& other302) { daysSinceEpoch = other302.daysSinceEpoch; +} +Date& Date::operator=(const Date& other303) { + daysSinceEpoch = other303.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7879,21 +7937,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other303) { - lowValue = other303.lowValue; - highValue = other303.highValue; - numNulls = other303.numNulls; - numDVs = other303.numDVs; - bitVectors = other303.bitVectors; - __isset = other303.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other304) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other304) { lowValue = other304.lowValue; highValue = other304.highValue; numNulls = other304.numNulls; numDVs = other304.numDVs; bitVectors = other304.bitVectors; __isset = other304.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other305) { + lowValue = other305.lowValue; + highValue = other305.highValue; + numNulls = other305.numNulls; + numDVs = other305.numDVs; + bitVectors = other305.bitVectors; + __isset = other305.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8079,17 +8137,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other305) { - booleanStats = other305.booleanStats; - longStats = other305.longStats; - doubleStats = other305.doubleStats; - stringStats = other305.stringStats; - binaryStats = other305.binaryStats; - decimalStats = other305.decimalStats; - dateStats = other305.dateStats; - __isset = other305.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other306) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other306) { booleanStats = other306.booleanStats; longStats = other306.longStats; doubleStats = other306.doubleStats; @@ -8098,6 +8146,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData decimalStats = other306.decimalStats; dateStats = other306.dateStats; __isset = other306.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other307) { + booleanStats = other307.booleanStats; + longStats = other307.longStats; + doubleStats = other307.doubleStats; + stringStats = other307.stringStats; + binaryStats = other307.binaryStats; + decimalStats = other307.decimalStats; + dateStats = other307.dateStats; + __isset = other307.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8225,15 +8283,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) { - colName = other307.colName; - colType = other307.colType; - statsData = other307.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other308) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other308) { colName = other308.colName; colType = other308.colType; statsData = other308.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other309) { + colName = other309.colName; + colType = other309.colType; + statsData = other309.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8396,21 +8454,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other309) { - isTblLevel = other309.isTblLevel; - dbName = other309.dbName; - tableName = other309.tableName; - partName = other309.partName; - lastAnalyzed = other309.lastAnalyzed; - __isset = other309.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other310) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other310) { isTblLevel = other310.isTblLevel; dbName = other310.dbName; tableName = other310.tableName; partName = other310.partName; lastAnalyzed = other310.lastAnalyzed; __isset = other310.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other311) { + isTblLevel = other311.isTblLevel; + dbName = other311.dbName; + tableName = other311.tableName; + partName = other311.partName; + lastAnalyzed = other311.lastAnalyzed; + __isset = other311.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8472,14 +8530,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size311; - ::apache::thrift::protocol::TType _etype314; - xfer += iprot->readListBegin(_etype314, _size311); - this->statsObj.resize(_size311); - uint32_t _i315; - for (_i315 = 0; _i315 < _size311; ++_i315) + uint32_t _size312; + ::apache::thrift::protocol::TType _etype315; + xfer += iprot->readListBegin(_etype315, _size312); + this->statsObj.resize(_size312); + uint32_t _i316; + for (_i316 = 0; _i316 < _size312; ++_i316) { - xfer += this->statsObj[_i315].read(iprot); + xfer += this->statsObj[_i316].read(iprot); } xfer += iprot->readListEnd(); } @@ -8516,10 +8574,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 _iter316; - for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); ++_iter316) + std::vector<ColumnStatisticsObj> ::const_iterator _iter317; + for (_iter317 = this->statsObj.begin(); _iter317 != this->statsObj.end(); ++_iter317) { - xfer += (*_iter316).write(oprot); + xfer += (*_iter317).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8536,13 +8594,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) { - statsDesc = other317.statsDesc; - statsObj = other317.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other318) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other318) { statsDesc = other318.statsDesc; statsObj = other318.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other319) { + statsDesc = other319.statsDesc; + statsObj = other319.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8593,14 +8651,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size319; - ::apache::thrift::protocol::TType _etype322; - xfer += iprot->readListBegin(_etype322, _size319); - this->colStats.resize(_size319); - uint32_t _i323; - for (_i323 = 0; _i323 < _size319; ++_i323) + uint32_t _size320; + ::apache::thrift::protocol::TType _etype323; + xfer += iprot->readListBegin(_etype323, _size320); + this->colStats.resize(_size320); + uint32_t _i324; + for (_i324 = 0; _i324 < _size320; ++_i324) { - xfer += this->colStats[_i323].read(iprot); + xfer += this->colStats[_i324].read(iprot); } xfer += iprot->readListEnd(); } @@ -8641,10 +8699,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 _iter324; - for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) + std::vector<ColumnStatisticsObj> ::const_iterator _iter325; + for (_iter325 = this->colStats.begin(); _iter325 != this->colStats.end(); ++_iter325) { - xfer += (*_iter324).write(oprot); + xfer += (*_iter325).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8665,13 +8723,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other325) { - colStats = other325.colStats; - partsFound = other325.partsFound; -} -AggrStats& AggrStats::operator=(const AggrStats& other326) { +AggrStats::AggrStats(const AggrStats& other326) { colStats = other326.colStats; partsFound = other326.partsFound; +} +AggrStats& AggrStats::operator=(const AggrStats& other327) { + colStats = other327.colStats; + partsFound = other327.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8722,14 +8780,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size327; - ::apache::thrift::protocol::TType _etype330; - xfer += iprot->readListBegin(_etype330, _size327); - this->colStats.resize(_size327); - uint32_t _i331; - for (_i331 = 0; _i331 < _size327; ++_i331) + uint32_t _size328; + ::apache::thrift::protocol::TType _etype331; + xfer += iprot->readListBegin(_etype331, _size328); + this->colStats.resize(_size328); + uint32_t _i332; + for (_i332 = 0; _i332 < _size328; ++_i332) { - xfer += this->colStats[_i331].read(iprot); + xfer += this->colStats[_i332].read(iprot); } xfer += iprot->readListEnd(); } @@ -8768,10 +8826,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 _iter332; - for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) + std::vector<ColumnStatistics> ::const_iterator _iter333; + for (_iter333 = this->colStats.begin(); _iter333 != this->colStats.end(); ++_iter333) { - xfer += (*_iter332).write(oprot); + xfer += (*_iter333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8794,15 +8852,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other333) { - colStats = other333.colStats; - needMerge = other333.needMerge; - __isset = other333.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other334) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other334) { colStats = other334.colStats; needMerge = other334.needMerge; __isset = other334.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other335) { + colStats = other335.colStats; + needMerge = other335.needMerge; + __isset = other335.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8851,14 +8909,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size335; - ::apache::thrift::protocol::TType _etype338; - xfer += iprot->readListBegin(_etype338, _size335); - this->fieldSchemas.resize(_size335); - uint32_t _i339; - for (_i339 = 0; _i339 < _size335; ++_i339) + uint32_t _size336; + ::apache::thrift::protocol::TType _etype339; + xfer += iprot->readListBegin(_etype339, _size336); + this->fieldSchemas.resize(_size336); + uint32_t _i340; + for (_i340 = 0; _i340 < _size336; ++_i340) { - xfer += this->fieldSchemas[_i339].read(iprot); + xfer += this->fieldSchemas[_i340].read(iprot); } xfer += iprot->readListEnd(); } @@ -8871,17 +8929,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size340; - ::apache::thrift::protocol::TType _ktype341; - ::apache::thrift::protocol::TType _vtype342; - xfer += iprot->readMapBegin(_ktype341, _vtype342, _size340); - uint32_t _i344; - for (_i344 = 0; _i344 < _size340; ++_i344) + uint32_t _size341; + ::apache::thrift::protocol::TType _ktype342; + ::apache::thrift::protocol::TType _vtype343; + xfer += iprot->readMapBegin(_ktype342, _vtype343, _size341); + uint32_t _i345; + for (_i345 = 0; _i345 < _size341; ++_i345) { - std::string _key345; - xfer += iprot->readString(_key345); - std::string& _val346 = this->properties[_key345]; - xfer += iprot->readString(_val346); + std::string _key346; + xfer += iprot->readString(_key346); + std::string& _val347 = this->properties[_key346]; + xfer += iprot->readString(_val347); } xfer += iprot->readMapEnd(); } @@ -8910,10 +8968,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 _iter347; - for (_iter347 = this->fieldSchemas.begin(); _iter347 != this->fieldSchemas.end(); ++_iter347) + std::vector<FieldSchema> ::const_iterator _iter348; + for (_iter348 = this->fieldSchemas.begin(); _iter348 != this->fieldSchemas.end(); ++_iter348) { - xfer += (*_iter347).write(oprot); + xfer += (*_iter348).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8922,11 +8980,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 _iter348; - for (_iter348 = this->properties.begin(); _iter348 != this->properties.end(); ++_iter348) + std::map<std::string, std::string> ::const_iterator _iter349; + for (_iter349 = this->properties.begin(); _iter349 != this->properties.end(); ++_iter349) { - xfer += oprot->writeString(_iter348->first); - xfer += oprot->writeString(_iter348->second); + xfer += oprot->writeString(_iter349->first); + xfer += oprot->writeString(_iter349->second); } xfer += oprot->writeMapEnd(); } @@ -8944,15 +9002,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other349) { - fieldSchemas = other349.fieldSchemas; - properties = other349.properties; - __isset = other349.__isset; -} -Schema& Schema::operator=(const Schema& other350) { +Schema::Schema(const Schema& other350) { fieldSchemas = other350.fieldSchemas; properties = other350.properties; __isset = other350.__isset; +} +Schema& Schema::operator=(const Schema& other351) { + fieldSchemas = other351.fieldSchemas; + properties = other351.properties; + __isset = other351.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8997,17 +9055,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size351; - ::apache::thrift::protocol::TType _ktype352; - ::apache::thrift::protocol::TType _vtype353; - xfer += iprot->readMapBegin(_ktype352, _vtype353, _size351); - uint32_t _i355; - for (_i355 = 0; _i355 < _size351; ++_i355) + uint32_t _size352; + ::apache::thrift::protocol::TType _ktype353; + ::apache::thrift::protocol::TType _vtype354; + xfer += iprot->readMapBegin(_ktype353, _vtype354, _size352); + uint32_t _i356; + for (_i356 = 0; _i356 < _size352; ++_i356) { - std::string _key356; - xfer += iprot->readString(_key356); - std::string& _val357 = this->properties[_key356]; - xfer += iprot->readString(_val357); + std::string _key357; + xfer += iprot->readString(_key357); + std::string& _val358 = this->properties[_key357]; + xfer += iprot->readString(_val358); } xfer += iprot->readMapEnd(); } @@ -9036,11 +9094,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 _iter358; - for (_iter358 = this->properties.begin(); _iter358 != this->properties.end(); ++_iter358) + std::map<std::string, std::string> ::const_iterator _iter359; + for (_iter359 = this->properties.begin(); _iter359 != this->properties.end(); ++_iter359) { - xfer += oprot->writeString(_iter358->first); - xfer += oprot->writeString(_iter358->second); + xfer += oprot->writeString(_iter359->first); + xfer += oprot->writeString(_iter359->second); } xfer += oprot->writeMapEnd(); } @@ -9057,13 +9115,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) { - properties = other359.properties; - __isset = other359.__isset; -} -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other360) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other360) { properties = other360.properties; __isset = other360.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other361) { + properties = other361.properties; + __isset = other361.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9165,13 +9223,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) { - db_name = other361.db_name; - tbl_name = other361.tbl_name; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other362) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other362) { db_name = other362.db_name; tbl_name = other362.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other363) { + db_name = other363.db_name; + tbl_name = other363.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9217,14 +9275,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size363; - ::apache::thrift::protocol::TType _etype366; - xfer += iprot->readListBegin(_etype366, _size363); - this->primaryKeys.resize(_size363); - uint32_t _i367; - for (_i367 = 0; _i367 < _size363; ++_i367) + uint32_t _size364; + ::apache::thrift::protocol::TType _etype367; + xfer += iprot->readListBegin(_etype367, _size364); + this->primaryKeys.resize(_size364); + uint32_t _i368; + for (_i368 = 0; _i368 < _size364; ++_i368) { - xfer += this->primaryKeys[_i367].read(iprot); + xfer += this->primaryKeys[_i368].read(iprot); } xfer += iprot->readListEnd(); } @@ -9255,10 +9313,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 _iter368; - for (_iter368 = this->primaryKeys.begin(); _iter368 != this->primaryKeys.end(); ++_iter368) + std::vector<SQLPrimaryKey> ::const_iterator _iter369; + for (_iter369 = this->primaryKeys.begin(); _iter369 != this->primaryKeys.end(); ++_iter369) { - xfer += (*_iter368).write(oprot); + xfer += (*_iter369).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9274,11 +9332,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) { - primaryKeys = other369.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other370) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other370) { primaryKeys = other370.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other371) { + primaryKeys = other371.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9409,19 +9467,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other371) { - parent_db_name = other371.parent_db_name; - parent_tbl_name = other371.parent_tbl_name; - foreign_db_name = other371.foreign_db_name; - foreign_tbl_name = other371.foreign_tbl_name; - __isset = other371.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other372) { +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other372) { parent_db_name = other372.parent_db_name; parent_tbl_name = other372.parent_tbl_name; foreign_db_name = other372.foreign_db_name; foreign_tbl_name = other372.foreign_tbl_name; __isset = other372.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other373) { + parent_db_name = other373.parent_db_name; + parent_tbl_name = other373.parent_tbl_name; + foreign_db_name = other373.foreign_db_name; + foreign_tbl_name = other373.foreign_tbl_name; + __isset = other373.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -9469,14 +9527,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size373; - ::apache::thrift::protocol::TType _etype376; - xfer += iprot->readListBegin(_etype376, _size373); - this->foreignKeys.resize(_size373); - uint32_t _i377; - for (_i377 = 0; _i377 < _size373; ++_i377) + uint32_t _size374; + ::apache::thrift::protocol::TType _etype377; + xfer += iprot->readListBegin(_etype377, _size374); + this->foreignKeys.resize(_size374); + uint32_t _i378; + for (_i378 = 0; _i378 < _size374; ++_i378) { - xfer += this->foreignKeys[_i377].read(iprot); + xfer += this->foreignKeys[_i378].read(iprot); } xfer += iprot->readListEnd(); } @@ -9507,10 +9565,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 _iter378; - for (_iter378 = this->foreignKeys.begin(); _iter378 != this->foreignKeys.end(); ++_iter378) + std::vector<SQLForeignKey> ::const_iterator _iter379; + for (_iter379 = this->foreignKeys.begin(); _iter379 != this->foreignKeys.end(); ++_iter379) { - xfer += (*_iter378).write(oprot); + xfer += (*_iter379).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9526,11 +9584,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other379) { - foreignKeys = other379.foreignKeys; -} -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other380) { +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other380) { foreignKeys = other380.foreignKeys; +} +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other381) { + foreignKeys = other381.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9632,13 +9690,13 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other381) { - db_name = other381.db_name; - tbl_name = other381.tbl_name; -} -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other382) { +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other382) { db_name = other382.db_name; tbl_name = other382.tbl_name; +} +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other383) { + db_name = other383.db_name; + tbl_name = other383.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -9684,14 +9742,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size383; - ::apache::thrift::protocol::TType _etype386; - xfer += iprot->readListBegin(_etype386, _size383); - this->uniqueConstraints.resize(_size383); - uint32_t _i387; - for (_i387 = 0; _i387 < _size383; ++_i387) + uint32_t _size384; + ::apache::thrift::protocol::TType _etype387; + xfer += iprot->readListBegin(_etype387, _size384); + this->uniqueConstraints.resize(_size384); + uint32_t _i388; + for (_i388 = 0; _i388 < _size384; ++_i388) { - xfer += this->uniqueConstraints[_i387].read(iprot); + xfer += this->uniqueConstraints[_i388].read(iprot); } xfer += iprot->readListEnd(); } @@ -9722,10 +9780,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size())); - std::vector<SQLUniqueConstraint> ::const_iterator _iter388; - for (_iter388 = this->uniqueConstraints.begin(); _iter388 != this->uniqueConstraints.end(); ++_iter388) + std::vector<SQLUniqueConstraint> ::const_iterator _iter389; + for (_iter389 = this->uniqueConstraints.begin(); _iter389 != this->uniqueConstraints.end(); ++_iter389) { - xfer += (*_iter388).write(oprot); + xfer += (*_iter389).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9741,11 +9799,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other389) { - uniqueConstraints = other389.uniqueConstraints; -} -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other390) { +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other390) { uniqueConstraints = other390.uniqueConstraints; +} +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other391) { + uniqueConstraints = other391.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -9847,13 +9905,13 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other391) { - db_name = other391.db_name; - tbl_name = other391.tbl_name; -} -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other392) { +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other392) { db_name = other392.db_name; tbl_name = other392.tbl_name; +} +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other393) { + db_name = other393.db_name; + tbl_name = other393.tbl_name; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -9899,14 +9957,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size393; - ::apache::thrift::protocol::TType _etype396; - xfer += iprot->readListBegin(_etype396, _size393); - this->notNullConstraints.resize(_size393); - uint32_t _i397; - for (_i397 = 0; _i397 < _size393; ++_i397) + uint32_t _size394; + ::apache::thrift::protocol::TType _etype397; + xfer += iprot->readListBegin(_etype397, _size394); + this->notNullConstraints.resize(_size394); + uint32_t _i398; + for (_i398 = 0; _i398 < _size394; ++_i398) { - xfer += this->notNullConstraints[_i397].read(iprot); + xfer += this->notNullConstraints[_i398].read(iprot); } xfer += iprot->readListEnd(); } @@ -9937,10 +9995,10 @@ uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size())); - std::vector<SQLNotNullConstraint> ::const_iterator _iter398; - for (_iter398 = this->notNullConstraints.begin(); _iter398 != this->notNullConstraints.end(); ++_iter398) + std::vector<SQLNotNullConstraint> ::const_iterator _iter399; + for (_iter399 = this->notNullConstraints.begin(); _iter399 != this->notNullConstraints.end(); ++_iter399) { - xfer += (*_iter398).write(oprot); + xfer += (*_iter399).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9956,11 +10014,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other399) { - notNullConstraints = other399.notNullConstraints; -} -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other400) { +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other400) { notNullConstraints = other400.notNullConstraints; +} +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other401) { + notNullConstraints = other401.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -10082,15 +10140,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other401) { - dbname = other401.dbname; - tablename = other401.tablename; - constraintname = other401.constraintname; -} -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other402) { +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other402) { dbname = other402.dbname; tablename = other402.tablename; constraintname = other402.constraintname; +} +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other403) { + dbname = other403.dbname; + tablename = other403.tablename; + constraintname = other403.constraintname; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -10137,14 +10195,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size403; - ::apache::thrift::protocol::TType _etype406; - xfer += iprot->readListBegin(_etype406, _size403); - this->primaryKeyCols.resize(_size403); - uint32_t _i407; - for (_i407 = 0; _i407 < _size403; ++_i407) + uint32_t _size404; + ::apache::thrift::protocol::TType _etype407; + xfer += iprot->readListBegin(_etype407, _size404); + this->primaryKeyCols.resize(_size404); + uint32_t _i408; + for (_i408 = 0; _i408 < _size404; ++_i408) { - xfer += this->primaryKeyCols[_i407].read(iprot); + xfer += this->primaryKeyCols[_i408].read(iprot); } xfer += iprot->readListEnd(); } @@ -10175,10 +10233,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 _iter408; - for (_iter408 = this->primaryKeyCols.begin(); _iter408 != this->primaryKeyCols.end(); ++_iter408) + std::vector<SQLPrimaryKey> ::const_iterator _iter409; + for (_iter409 = this->primaryKeyCols.begin(); _iter409 != this->primaryKeyCols.end(); ++_iter409) { - xfer += (*_iter408).write(oprot); + xfer += (*_iter409).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10194,11 +10252,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other409) { - primaryKeyCols = other409.primaryKeyCols; -} -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other410) { +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other410) { primaryKeyCols = other410.primaryKeyCols; +} +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other411) { + primaryKeyCols = other411.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -10243,14 +10301,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size411; - ::apache::thrift::protocol::TType _etype414; - xfer += iprot->readListBegin(_etype414, _size411); - this->foreignKeyCols.resize(_size411); - uint32_t _i415; - for (_i415 = 0; _i415 < _size411; ++_i415) + uint32_t _size412; + ::apache::thrift::protocol::TType _etype415; + xfer += iprot->readListBegin(_etype415, _size412); + this->foreignKeyCols.resize(_size412); + uint32_t _i416; + for (_i416 = 0; _i416 < _size412; ++_i416) { - xfer += this->foreignKeyCols[_i415].read(iprot); + xfer += this->foreignKeyCols[_i416].read(iprot); } xfer += iprot->readListEnd(); } @@ -10281,10 +10339,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 _iter416; - for (_iter416 = this->foreignKeyCols.begin(); _iter416 != this->foreignKeyCols.end(); ++_iter416) + std::vector<SQLForeignKey> ::const_iterator _iter417; + for (_iter417 = this->foreignKeyCols.begin(); _iter417 != this->foreignKeyCols.end(); ++_iter417) { - xfer += (*_iter416).write(oprot); + xfer += (*_iter417).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10300,11 +10358,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other417) { - foreignKeyCols = other417.foreignKeyCols; -} -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other418) { +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other418) { foreignKeyCols = other418.foreignKeyCols; +} +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other419) { + foreignKeyCols = other419.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -10349,14 +10407,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - uint32_t _size419; - ::apache::thrift::protocol::TType _etype422; - xfer += iprot->readListBegin(_etype422, _size419); - this->uniqueConstraintCols.resize(_size419); - uint32_t _i423; - for (_i423 = 0; _i423 < _size419; ++_i423) + uint32_t _size420; + ::apache::thrift::protocol::TType _etype423; + xfer += iprot->readListBegin(_etype423, _size420); + this->uniqueConstraintCols.resize(_size420); + uint32_t _i424; + for (_i424 = 0; _i424 < _size420; ++_i424) { - xfer += this->uniqueConstraintCols[_i423].read(iprot); + xfer += this->uniqueConstraintCols[_i424].read(iprot); } xfer += iprot->readListEnd(); } @@ -10387,10 +10445,10 @@ uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraintCols.size())); - std::vector<SQLUniqueConstraint> ::const_iterator _iter424; - for (_iter424 = this->uniqueConstraintCols.begin(); _iter424 != this->uniqueConstraintCols.end(); ++_iter424) + std::vector<SQLUniqueConstraint> ::const_iterator _iter425; + for (_iter425 = this->uniqueConstraintCols.begin(); _iter425 != this->uniqueConstraintCols.end(); ++_iter425) { - xfer += (*_iter424).write(oprot); + xfer += (*_iter425).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10406,11 +10464,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other425) { - uniqueConstraintCols = other425.uniqueConstraintCols; -} -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other426) { +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other426) { uniqueConstraintCols = other426.uniqueConstraintCols; +} +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other427) { + uniqueConstraintCols = other427.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -10455,14 +10513,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - uint32_t _size427; - ::apache::thrift::protocol::TType _etype430; - xfer += iprot->readListBegin(_etype430, _size427); - this->notNullConstraintCols.resize(_size427); - uint32_t _i431; - for (_i431 = 0; _i431 < _size427; ++_i431) + uint32_t _size428; + ::apache::thrift::protocol::TType _etype431; + xfer += iprot->readListBegin(_etype431, _size428); + this->notNullConstraintCols.resize(_size428); + uint32_t _i432; + for (_i432 = 0; _i432 < _size428; ++_i432) { - xfer += this->notNullConstraintCols[_i431].read(iprot); + xfer += this->notNullConstraintCols[_i432].read(iprot); } xfer += iprot->readListEnd(); } @@ -10493,10 +10551,10 @@ uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraintCols.size())); - std::vector<SQLNotNullConstraint> ::const_iterator _iter432; - for (_iter432 = this->notNullConstraintCols.begin(); _iter432 != this->notNullConstraintCols.end(); ++_iter432) + std::vector<SQLNotNullConstraint> ::const_iterator _iter433; + for (_iter433 = this->notNullConstraintCols.begin(); _iter433 != this->notNullConstraintCols.end(); ++_iter433) { - xfer += (*_iter432).write(oprot); + xfer += (*_iter433).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10512,11 +10570,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other433) { - notNullConstraintCols = other433.notNullConstraintCols; -} -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other434) { +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other434) { notNullConstraintCols = other434.notNullConstraintCols; +} +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other435) { + notNullConstraintCols = other435.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -10566,14 +10624,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size435; - ::apache::thrift::protocol::TType _etype438; - xfer += iprot->readListBegin(_etype438, _size435); - this->partitions.resize(_size435); - uint32_t _i439; - for (_i439 = 0; _i439 < _size435; ++_i439) + uint32_t _size436; + ::apache::thrift::protocol::TType _etype439; + xfer += iprot->readListBegin(_etype439, _size436); + this->partitions.resize(_size436); + uint32_t _i440; + for (_i440 = 0; _i440 < _size436; ++_i440) { - xfer += this->partitions[_i439].read(iprot); + xfer += this->partitions[_i440].read(iprot); } xfer += iprot->readListEnd(); } @@ -10614,10 +10672,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 _iter440; - for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) + std::vector<Partition> ::const_iterator _iter441; + for (_iter441 = this->partitions.begin(); _iter441 != this->partitions.end(); ++_iter441) { - xfer += (*_iter440).write(oprot); + xfer += (*_iter441).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10638,13 +10696,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other441) { - partitions = other441.partitions; - hasUnknownPartitions = other441.hasUnknownPartitions; -} -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other442) { +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other442) { partitions = other442.partitions; hasUnknownPartitions = other442.hasUnknownPartitions; +} +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other443) { + partitions = other443.partitions; + hasUnknownPartitions = other443.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -10806,21 +10864,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other443) { - dbName = other443.dbName; - tblName = other443.tblName; - expr = other443.expr; - defaultPartitionName = other443.defaultPartitionName; - maxParts = other443.maxParts; - __isset = other443.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other444) { +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other444) { dbName = other444.dbName; tblName = other444.tblName; expr = other444.expr; defaultPartitionName = other444.defaultPartitionName; maxParts = other444.maxParts; __isset = other444.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other445) { + dbName = other445.dbName; + tblName = other445.tblName; + expr = other445.expr; + defaultPartitionName = other445.defaultPartitionName; + maxParts = other445.maxParts; + __isset = other445.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -10869,14 +10927,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size445; - ::apache::thrift::protocol::TType _etype448; - xfer += iprot->readListBegin(_etype448, _size445); - this->tableStats.resize(_size445); - uint32_t _i449; - for (_i449 = 0; _i449 < _size445; ++_i449) + uint32_t _size446; + ::apache::thrift::protocol::TType _etype449; + xfer += iprot->readListBegin(_etype449, _size446); + this->tableStats.resize(_size446); + uint32_t _i450; + for (_i450 = 0; _i450 < _size446; ++_i450) { - xfer += this->tableStats[_i449].read(iprot); + xfer += this->tableStats[_i450].read(iprot); } xfer += iprot->readListEnd(); } @@ -10907,10 +10965,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 _iter450; - for (_iter450 = this->tableStats.begin(); _iter450 != this->tableStats.end(); ++_iter450) + std::vector<ColumnStatisticsObj> ::const_iterator _iter451; + for (_iter451 = this->tableStats.begin(); _iter451 != this->tableStats.end(); ++_iter451) { - xfer += (*_iter450).write(oprot); + xfer += (*_iter451).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10926,11 +10984,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other451) { - tableStats = other451.tableStats; -} -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other452) { +TableStatsResult::TableStatsResult(const TableStatsResult& other452) { tableStats = other452.tableStats; +} +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other453) { + tableStats = other453.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -10975,26 +11033,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size453; - ::apache::thrift::protocol::TType _ktype454; - ::apache::thrift::protocol::TType _vtype455; - xfer += iprot->readMapBegin(_ktype454, _vtype455, _size453); - uint32_t _i457; - for (_i457 = 0; _i457 < _size453; ++_i457) + uint32_t _size454; + ::apache::thrift::protocol::TType _ktype455; + ::apache::thrift::protocol::TType _vtype456; + xfer += iprot->readMapBegin(_ktype455, _vtype456, _size454); + uint32_t _i458; + for (_i458 = 0; _i458 < _size
<TRUNCATED>
