http://git-wip-us.apache.org/repos/asf/hive/blob/3464df45/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 2169265..aadf8f1 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,18 +149,6 @@ 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 }; @@ -4957,16 +4945,6 @@ 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); @@ -5143,24 +5121,6 @@ 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; @@ -5209,10 +5169,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 _iter224; - for (_iter224 = this->partitionKeys.begin(); _iter224 != this->partitionKeys.end(); ++_iter224) + std::vector<FieldSchema> ::const_iterator _iter223; + for (_iter223 = this->partitionKeys.begin(); _iter223 != this->partitionKeys.end(); ++_iter223) { - xfer += (*_iter224).write(oprot); + xfer += (*_iter223).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5221,11 +5181,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 _iter225; - for (_iter225 = this->parameters.begin(); _iter225 != this->parameters.end(); ++_iter225) + std::map<std::string, std::string> ::const_iterator _iter224; + for (_iter224 = this->parameters.begin(); _iter224 != this->parameters.end(); ++_iter224) { - xfer += oprot->writeString(_iter225->first); - xfer += oprot->writeString(_iter225->second); + xfer += oprot->writeString(_iter224->first); + xfer += oprot->writeString(_iter224->second); } xfer += oprot->writeMapEnd(); } @@ -5263,16 +5223,6 @@ 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; @@ -5296,12 +5246,29 @@ 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& other226) { +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) { tableName = other226.tableName; dbName = other226.dbName; owner = other226.owner; @@ -5318,30 +5285,7 @@ Table::Table(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 { @@ -5363,8 +5307,6 @@ 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 << ")"; } @@ -5431,14 +5373,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - 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) + 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) { - xfer += iprot->readString(this->values[_i232]); + xfer += iprot->readString(this->values[_i231]); } xfer += iprot->readListEnd(); } @@ -5491,17 +5433,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - 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) + 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) { - std::string _key238; - xfer += iprot->readString(_key238); - std::string& _val239 = this->parameters[_key238]; - xfer += iprot->readString(_val239); + std::string _key237; + xfer += iprot->readString(_key237); + std::string& _val238 = this->parameters[_key237]; + xfer += iprot->readString(_val238); } xfer += iprot->readMapEnd(); } @@ -5538,10 +5480,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 _iter240; - for (_iter240 = this->values.begin(); _iter240 != this->values.end(); ++_iter240) + std::vector<std::string> ::const_iterator _iter239; + for (_iter239 = this->values.begin(); _iter239 != this->values.end(); ++_iter239) { - xfer += oprot->writeString((*_iter240)); + xfer += oprot->writeString((*_iter239)); } xfer += oprot->writeListEnd(); } @@ -5570,11 +5512,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 _iter241; - for (_iter241 = this->parameters.begin(); _iter241 != this->parameters.end(); ++_iter241) + std::map<std::string, std::string> ::const_iterator _iter240; + for (_iter240 = this->parameters.begin(); _iter240 != this->parameters.end(); ++_iter240) { - xfer += oprot->writeString(_iter241->first); - xfer += oprot->writeString(_iter241->second); + xfer += oprot->writeString(_iter240->first); + xfer += oprot->writeString(_iter240->second); } xfer += oprot->writeMapEnd(); } @@ -5603,7 +5545,18 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other242) { +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) { values = other242.values; dbName = other242.dbName; tableName = other242.tableName; @@ -5613,17 +5566,6 @@ Partition::Partition(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 { @@ -5695,14 +5637,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - 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) + 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) { - xfer += iprot->readString(this->values[_i248]); + xfer += iprot->readString(this->values[_i247]); } xfer += iprot->readListEnd(); } @@ -5739,17 +5681,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - 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) + 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) { - std::string _key254; - xfer += iprot->readString(_key254); - std::string& _val255 = this->parameters[_key254]; - xfer += iprot->readString(_val255); + std::string _key253; + xfer += iprot->readString(_key253); + std::string& _val254 = this->parameters[_key253]; + xfer += iprot->readString(_val254); } xfer += iprot->readMapEnd(); } @@ -5786,10 +5728,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 _iter256; - for (_iter256 = this->values.begin(); _iter256 != this->values.end(); ++_iter256) + std::vector<std::string> ::const_iterator _iter255; + for (_iter255 = this->values.begin(); _iter255 != this->values.end(); ++_iter255) { - xfer += oprot->writeString((*_iter256)); + xfer += oprot->writeString((*_iter255)); } xfer += oprot->writeListEnd(); } @@ -5810,11 +5752,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 _iter257; - for (_iter257 = this->parameters.begin(); _iter257 != this->parameters.end(); ++_iter257) + std::map<std::string, std::string> ::const_iterator _iter256; + for (_iter256 = this->parameters.begin(); _iter256 != this->parameters.end(); ++_iter256) { - xfer += oprot->writeString(_iter257->first); - xfer += oprot->writeString(_iter257->second); + xfer += oprot->writeString(_iter256->first); + xfer += oprot->writeString(_iter256->second); } xfer += oprot->writeMapEnd(); } @@ -5841,7 +5783,16 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other258) { +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) { values = other258.values; createTime = other258.createTime; lastAccessTime = other258.lastAccessTime; @@ -5849,15 +5800,6 @@ PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other258) { 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 { @@ -5910,14 +5852,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + uint32_t _size259; + ::apache::thrift::protocol::TType _etype262; + xfer += iprot->readListBegin(_etype262, _size259); + this->partitions.resize(_size259); + uint32_t _i263; + for (_i263 = 0; _i263 < _size259; ++_i263) { - xfer += this->partitions[_i264].read(iprot); + xfer += this->partitions[_i263].read(iprot); } xfer += iprot->readListEnd(); } @@ -5954,10 +5896,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 _iter265; - for (_iter265 = this->partitions.begin(); _iter265 != this->partitions.end(); ++_iter265) + std::vector<PartitionWithoutSD> ::const_iterator _iter264; + for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264) { - xfer += (*_iter265).write(oprot); + xfer += (*_iter264).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5979,15 +5921,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other266) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other265) { + partitions = other265.partitions; + sd = other265.sd; + __isset = other265.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(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 { @@ -6032,14 +5974,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + 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) { - xfer += this->partitions[_i272].read(iprot); + xfer += this->partitions[_i271].read(iprot); } xfer += iprot->readListEnd(); } @@ -6068,10 +6010,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 _iter273; - for (_iter273 = this->partitions.begin(); _iter273 != this->partitions.end(); ++_iter273) + std::vector<Partition> ::const_iterator _iter272; + for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) { - xfer += (*_iter273).write(oprot); + xfer += (*_iter272).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6088,13 +6030,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other274) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other273) { + partitions = other273.partitions; + __isset = other273.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(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 { @@ -6246,21 +6188,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other276) { +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) { 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 { @@ -6408,17 +6350,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - 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) + 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) { - std::string _key283; - xfer += iprot->readString(_key283); - std::string& _val284 = this->parameters[_key283]; - xfer += iprot->readString(_val284); + std::string _key282; + xfer += iprot->readString(_key282); + std::string& _val283 = this->parameters[_key282]; + xfer += iprot->readString(_val283); } xfer += iprot->readMapEnd(); } @@ -6487,11 +6429,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 _iter285; - for (_iter285 = this->parameters.begin(); _iter285 != this->parameters.end(); ++_iter285) + std::map<std::string, std::string> ::const_iterator _iter284; + for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284) { - xfer += oprot->writeString(_iter285->first); - xfer += oprot->writeString(_iter285->second); + xfer += oprot->writeString(_iter284->first); + xfer += oprot->writeString(_iter284->second); } xfer += oprot->writeMapEnd(); } @@ -6521,7 +6463,20 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other286) { +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) { indexName = other286.indexName; indexHandlerClass = other286.indexHandlerClass; dbName = other286.dbName; @@ -6533,19 +6488,6 @@ Index::Index(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 { @@ -6696,19 +6638,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other288) { +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) { 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 { @@ -6871,21 +6813,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other290) { +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) { 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 { @@ -7049,21 +6991,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other292) { +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) { 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 { @@ -7229,21 +7171,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other294) { +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) { 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 { @@ -7389,19 +7331,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other296) { +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) { 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 { @@ -7506,13 +7448,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other298) { +Decimal::Decimal(const Decimal& other297) { + unscaled = other297.unscaled; + scale = other297.scale; +} +Decimal& Decimal::operator=(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 { @@ -7673,21 +7615,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other300) { +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) { 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 { @@ -7773,11 +7715,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other302) { - daysSinceEpoch = other302.daysSinceEpoch; +Date::Date(const Date& other301) { + daysSinceEpoch = other301.daysSinceEpoch; } -Date& Date::operator=(const Date& other303) { - daysSinceEpoch = other303.daysSinceEpoch; +Date& Date::operator=(const Date& other302) { + daysSinceEpoch = other302.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7937,21 +7879,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other304) { +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) { 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 { @@ -8137,7 +8079,17 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other306) { +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) { booleanStats = other306.booleanStats; longStats = other306.longStats; doubleStats = other306.doubleStats; @@ -8146,16 +8098,6 @@ ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other306) 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 { @@ -8283,15 +8225,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other308) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) { + colName = other307.colName; + colType = other307.colType; + statsData = other307.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(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 { @@ -8454,21 +8396,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other310) { +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) { 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 { @@ -8530,14 +8472,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - 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) + 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) { - xfer += this->statsObj[_i316].read(iprot); + xfer += this->statsObj[_i315].read(iprot); } xfer += iprot->readListEnd(); } @@ -8574,10 +8516,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 _iter317; - for (_iter317 = this->statsObj.begin(); _iter317 != this->statsObj.end(); ++_iter317) + std::vector<ColumnStatisticsObj> ::const_iterator _iter316; + for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); ++_iter316) { - xfer += (*_iter317).write(oprot); + xfer += (*_iter316).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8594,13 +8536,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other318) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) { + statsDesc = other317.statsDesc; + statsObj = other317.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(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 { @@ -8651,14 +8593,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - 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) + 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) { - xfer += this->colStats[_i324].read(iprot); + xfer += this->colStats[_i323].read(iprot); } xfer += iprot->readListEnd(); } @@ -8699,10 +8641,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 _iter325; - for (_iter325 = this->colStats.begin(); _iter325 != this->colStats.end(); ++_iter325) + std::vector<ColumnStatisticsObj> ::const_iterator _iter324; + for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) { - xfer += (*_iter325).write(oprot); + xfer += (*_iter324).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8723,13 +8665,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other326) { +AggrStats::AggrStats(const AggrStats& other325) { + colStats = other325.colStats; + partsFound = other325.partsFound; +} +AggrStats& AggrStats::operator=(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 { @@ -8780,14 +8722,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - 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) + 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) { - xfer += this->colStats[_i332].read(iprot); + xfer += this->colStats[_i331].read(iprot); } xfer += iprot->readListEnd(); } @@ -8826,10 +8768,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 _iter333; - for (_iter333 = this->colStats.begin(); _iter333 != this->colStats.end(); ++_iter333) + std::vector<ColumnStatistics> ::const_iterator _iter332; + for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) { - xfer += (*_iter333).write(oprot); + xfer += (*_iter332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8852,15 +8794,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other334) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other333) { + colStats = other333.colStats; + needMerge = other333.needMerge; + __isset = other333.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(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 { @@ -8909,14 +8851,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - 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) + 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) { - xfer += this->fieldSchemas[_i340].read(iprot); + xfer += this->fieldSchemas[_i339].read(iprot); } xfer += iprot->readListEnd(); } @@ -8929,17 +8871,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - 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) + 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) { - std::string _key346; - xfer += iprot->readString(_key346); - std::string& _val347 = this->properties[_key346]; - xfer += iprot->readString(_val347); + std::string _key345; + xfer += iprot->readString(_key345); + std::string& _val346 = this->properties[_key345]; + xfer += iprot->readString(_val346); } xfer += iprot->readMapEnd(); } @@ -8968,10 +8910,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 _iter348; - for (_iter348 = this->fieldSchemas.begin(); _iter348 != this->fieldSchemas.end(); ++_iter348) + std::vector<FieldSchema> ::const_iterator _iter347; + for (_iter347 = this->fieldSchemas.begin(); _iter347 != this->fieldSchemas.end(); ++_iter347) { - xfer += (*_iter348).write(oprot); + xfer += (*_iter347).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8980,11 +8922,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 _iter349; - for (_iter349 = this->properties.begin(); _iter349 != this->properties.end(); ++_iter349) + std::map<std::string, std::string> ::const_iterator _iter348; + for (_iter348 = this->properties.begin(); _iter348 != this->properties.end(); ++_iter348) { - xfer += oprot->writeString(_iter349->first); - xfer += oprot->writeString(_iter349->second); + xfer += oprot->writeString(_iter348->first); + xfer += oprot->writeString(_iter348->second); } xfer += oprot->writeMapEnd(); } @@ -9002,15 +8944,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other350) { +Schema::Schema(const Schema& other349) { + fieldSchemas = other349.fieldSchemas; + properties = other349.properties; + __isset = other349.__isset; +} +Schema& Schema::operator=(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 { @@ -9055,17 +8997,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - 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) + 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) { - std::string _key357; - xfer += iprot->readString(_key357); - std::string& _val358 = this->properties[_key357]; - xfer += iprot->readString(_val358); + std::string _key356; + xfer += iprot->readString(_key356); + std::string& _val357 = this->properties[_key356]; + xfer += iprot->readString(_val357); } xfer += iprot->readMapEnd(); } @@ -9094,11 +9036,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 _iter359; - for (_iter359 = this->properties.begin(); _iter359 != this->properties.end(); ++_iter359) + std::map<std::string, std::string> ::const_iterator _iter358; + for (_iter358 = this->properties.begin(); _iter358 != this->properties.end(); ++_iter358) { - xfer += oprot->writeString(_iter359->first); - xfer += oprot->writeString(_iter359->second); + xfer += oprot->writeString(_iter358->first); + xfer += oprot->writeString(_iter358->second); } xfer += oprot->writeMapEnd(); } @@ -9115,13 +9057,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other360) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) { + properties = other359.properties; + __isset = other359.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(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 { @@ -9223,13 +9165,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other362) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) { + db_name = other361.db_name; + tbl_name = other361.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(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 { @@ -9275,14 +9217,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - 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) + 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) { - xfer += this->primaryKeys[_i368].read(iprot); + xfer += this->primaryKeys[_i367].read(iprot); } xfer += iprot->readListEnd(); } @@ -9313,10 +9255,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 _iter369; - for (_iter369 = this->primaryKeys.begin(); _iter369 != this->primaryKeys.end(); ++_iter369) + std::vector<SQLPrimaryKey> ::const_iterator _iter368; + for (_iter368 = this->primaryKeys.begin(); _iter368 != this->primaryKeys.end(); ++_iter368) { - xfer += (*_iter369).write(oprot); + xfer += (*_iter368).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9332,11 +9274,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other370) { - primaryKeys = other370.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) { + primaryKeys = other369.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other371) { - primaryKeys = other371.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other370) { + primaryKeys = other370.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9467,19 +9409,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other372) { +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) { 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 { @@ -9527,14 +9469,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - 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) + 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) { - xfer += this->foreignKeys[_i378].read(iprot); + xfer += this->foreignKeys[_i377].read(iprot); } xfer += iprot->readListEnd(); } @@ -9565,10 +9507,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 _iter379; - for (_iter379 = this->foreignKeys.begin(); _iter379 != this->foreignKeys.end(); ++_iter379) + std::vector<SQLForeignKey> ::const_iterator _iter378; + for (_iter378 = this->foreignKeys.begin(); _iter378 != this->foreignKeys.end(); ++_iter378) { - xfer += (*_iter379).write(oprot); + xfer += (*_iter378).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9584,11 +9526,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other380) { - foreignKeys = other380.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other379) { + foreignKeys = other379.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other381) { - foreignKeys = other381.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other380) { + foreignKeys = other380.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9690,13 +9632,13 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other382) { +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other381) { + db_name = other381.db_name; + tbl_name = other381.tbl_name; +} +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(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 { @@ -9742,14 +9684,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - 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) + 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) { - xfer += this->uniqueConstraints[_i388].read(iprot); + xfer += this->uniqueConstraints[_i387].read(iprot); } xfer += iprot->readListEnd(); } @@ -9780,10 +9722,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 _iter389; - for (_iter389 = this->uniqueConstraints.begin(); _iter389 != this->uniqueConstraints.end(); ++_iter389) + std::vector<SQLUniqueConstraint> ::const_iterator _iter388; + for (_iter388 = this->uniqueConstraints.begin(); _iter388 != this->uniqueConstraints.end(); ++_iter388) { - xfer += (*_iter389).write(oprot); + xfer += (*_iter388).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9799,11 +9741,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other390) { - uniqueConstraints = other390.uniqueConstraints; +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other389) { + uniqueConstraints = other389.uniqueConstraints; } -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other391) { - uniqueConstraints = other391.uniqueConstraints; +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other390) { + uniqueConstraints = other390.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -9905,13 +9847,13 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other392) { +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other391) { + db_name = other391.db_name; + tbl_name = other391.tbl_name; +} +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(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 { @@ -9957,14 +9899,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - 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) + 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) { - xfer += this->notNullConstraints[_i398].read(iprot); + xfer += this->notNullConstraints[_i397].read(iprot); } xfer += iprot->readListEnd(); } @@ -9995,10 +9937,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 _iter399; - for (_iter399 = this->notNullConstraints.begin(); _iter399 != this->notNullConstraints.end(); ++_iter399) + std::vector<SQLNotNullConstraint> ::const_iterator _iter398; + for (_iter398 = this->notNullConstraints.begin(); _iter398 != this->notNullConstraints.end(); ++_iter398) { - xfer += (*_iter399).write(oprot); + xfer += (*_iter398).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10014,11 +9956,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other400) { - notNullConstraints = other400.notNullConstraints; +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other399) { + notNullConstraints = other399.notNullConstraints; } -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other401) { - notNullConstraints = other401.notNullConstraints; +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other400) { + notNullConstraints = other400.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -10140,15 +10082,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other402) { +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other401) { + dbname = other401.dbname; + tablename = other401.tablename; + constraintname = other401.constraintname; +} +DropConstraintRequest& DropConstraintRequest::operator=(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 { @@ -10195,14 +10137,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - 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) + 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) { - xfer += this->primaryKeyCols[_i408].read(iprot); + xfer += this->primaryKeyCols[_i407].read(iprot); } xfer += iprot->readListEnd(); } @@ -10233,10 +10175,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 _iter409; - for (_iter409 = this->primaryKeyCols.begin(); _iter409 != this->primaryKeyCols.end(); ++_iter409) + std::vector<SQLPrimaryKey> ::const_iterator _iter408; + for (_iter408 = this->primaryKeyCols.begin(); _iter408 != this->primaryKeyCols.end(); ++_iter408) { - xfer += (*_iter409).write(oprot); + xfer += (*_iter408).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10252,11 +10194,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other410) { - primaryKeyCols = other410.primaryKeyCols; +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other409) { + primaryKeyCols = other409.primaryKeyCols; } -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other411) { - primaryKeyCols = other411.primaryKeyCols; +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other410) { + primaryKeyCols = other410.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -10301,14 +10243,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - 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) + 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) { - xfer += this->foreignKeyCols[_i416].read(iprot); + xfer += this->foreignKeyCols[_i415].read(iprot); } xfer += iprot->readListEnd(); } @@ -10339,10 +10281,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 _iter417; - for (_iter417 = this->foreignKeyCols.begin(); _iter417 != this->foreignKeyCols.end(); ++_iter417) + std::vector<SQLForeignKey> ::const_iterator _iter416; + for (_iter416 = this->foreignKeyCols.begin(); _iter416 != this->foreignKeyCols.end(); ++_iter416) { - xfer += (*_iter417).write(oprot); + xfer += (*_iter416).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10358,11 +10300,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other418) { - foreignKeyCols = other418.foreignKeyCols; +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other417) { + foreignKeyCols = other417.foreignKeyCols; } -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other419) { - foreignKeyCols = other419.foreignKeyCols; +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other418) { + foreignKeyCols = other418.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -10407,14 +10349,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - 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) + 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) { - xfer += this->uniqueConstraintCols[_i424].read(iprot); + xfer += this->uniqueConstraintCols[_i423].read(iprot); } xfer += iprot->readListEnd(); } @@ -10445,10 +10387,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 _iter425; - for (_iter425 = this->uniqueConstraintCols.begin(); _iter425 != this->uniqueConstraintCols.end(); ++_iter425) + std::vector<SQLUniqueConstraint> ::const_iterator _iter424; + for (_iter424 = this->uniqueConstraintCols.begin(); _iter424 != this->uniqueConstraintCols.end(); ++_iter424) { - xfer += (*_iter425).write(oprot); + xfer += (*_iter424).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10464,11 +10406,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other426) { - uniqueConstraintCols = other426.uniqueConstraintCols; +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other425) { + uniqueConstraintCols = other425.uniqueConstraintCols; } -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other427) { - uniqueConstraintCols = other427.uniqueConstraintCols; +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other426) { + uniqueConstraintCols = other426.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -10513,14 +10455,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - 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) + 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) { - xfer += this->notNullConstraintCols[_i432].read(iprot); + xfer += this->notNullConstraintCols[_i431].read(iprot); } xfer += iprot->readListEnd(); } @@ -10551,10 +10493,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 _iter433; - for (_iter433 = this->notNullConstraintCols.begin(); _iter433 != this->notNullConstraintCols.end(); ++_iter433) + std::vector<SQLNotNullConstraint> ::const_iterator _iter432; + for (_iter432 = this->notNullConstraintCols.begin(); _iter432 != this->notNullConstraintCols.end(); ++_iter432) { - xfer += (*_iter433).write(oprot); + xfer += (*_iter432).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10570,11 +10512,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other434) { - notNullConstraintCols = other434.notNullConstraintCols; +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other433) { + notNullConstraintCols = other433.notNullConstraintCols; } -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other435) { - notNullConstraintCols = other435.notNullConstraintCols; +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other434) { + notNullConstraintCols = other434.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -10624,14 +10566,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + 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) { - xfer += this->partitions[_i440].read(iprot); + xfer += this->partitions[_i439].read(iprot); } xfer += iprot->readListEnd(); } @@ -10672,10 +10614,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 _iter441; - for (_iter441 = this->partitions.begin(); _iter441 != this->partitions.end(); ++_iter441) + std::vector<Partition> ::const_iterator _iter440; + for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) { - xfer += (*_iter441).write(oprot); + xfer += (*_iter440).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10696,13 +10638,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other442) { +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other441) { + partitions = other441.partitions; + hasUnknownPartitions = other441.hasUnknownPartitions; +} +PartitionsByExprResult& PartitionsByExprResult::operator=(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 { @@ -10864,21 +10806,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other444) { +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) { 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 { @@ -10927,14 +10869,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - 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) + 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) { - xfer += this->tableStats[_i450].read(iprot); + xfer += this->tableStats[_i449].read(iprot); } xfer += iprot->readListEnd(); } @@ -10965,10 +10907,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 _iter451; - for (_iter451 = this->tableStats.begin(); _iter451 != this->tableStats.end(); ++_iter451) + std::vector<ColumnStatisticsObj> ::const_iterator _iter450; + for (_iter450 = this->tableStats.begin(); _iter450 != this->tableStats.end(); ++_iter450) { - xfer += (*_iter451).write(oprot); + xfer += (*_iter450).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10984,11 +10926,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other452) { - tableStats = other452.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other451) { + tableStats = other451.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other453) { - tableStats = other453.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other452) { + tableStats = other452.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -11033,26 +10975,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size454; - ::apache::thrift::protocol::TType _ktype455; - ::apache::thrift::protocol::TType _vtype456; - xfer += iprot->readMapBegin(_ktype45
<TRUNCATED>
