http://git-wip-us.apache.org/repos/asf/hive/blob/0a328f03/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 27f8c0f..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 @@ -4940,7 +4940,7 @@ void Table::__set_rewriteEnabled(const bool val) { __isset.rewriteEnabled = true; } -void Table::__set_creationMetadata(const std::map<std::string, BasicTxnInfo> & val) { +void Table::__set_creationMetadata(const CreationMetadata& val) { this->creationMetadata = val; __isset.creationMetadata = true; } @@ -5114,23 +5114,8 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { } break; case 16: - if (ftype == ::apache::thrift::protocol::T_MAP) { - { - this->creationMetadata.clear(); - uint32_t _size223; - ::apache::thrift::protocol::TType _ktype224; - ::apache::thrift::protocol::TType _vtype225; - xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223); - uint32_t _i227; - for (_i227 = 0; _i227 < _size223; ++_i227) - { - std::string _key228; - xfer += iprot->readString(_key228); - BasicTxnInfo& _val229 = this->creationMetadata[_key228]; - xfer += _val229.read(iprot); - } - xfer += iprot->readMapEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->creationMetadata.read(iprot); this->__isset.creationMetadata = true; } else { xfer += iprot->skip(ftype); @@ -5184,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 _iter230; - for (_iter230 = this->partitionKeys.begin(); _iter230 != this->partitionKeys.end(); ++_iter230) + std::vector<FieldSchema> ::const_iterator _iter223; + for (_iter223 = this->partitionKeys.begin(); _iter223 != this->partitionKeys.end(); ++_iter223) { - xfer += (*_iter230).write(oprot); + xfer += (*_iter223).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5196,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 _iter231; - for (_iter231 = this->parameters.begin(); _iter231 != this->parameters.end(); ++_iter231) + std::map<std::string, std::string> ::const_iterator _iter224; + for (_iter224 = this->parameters.begin(); _iter224 != this->parameters.end(); ++_iter224) { - xfer += oprot->writeString(_iter231->first); - xfer += oprot->writeString(_iter231->second); + xfer += oprot->writeString(_iter224->first); + xfer += oprot->writeString(_iter224->second); } xfer += oprot->writeMapEnd(); } @@ -5234,17 +5219,8 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldEnd(); } if (this->__isset.creationMetadata) { - xfer += oprot->writeFieldBegin("creationMetadata", ::apache::thrift::protocol::T_MAP, 16); - { - xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->creationMetadata.size())); - std::map<std::string, BasicTxnInfo> ::const_iterator _iter232; - for (_iter232 = this->creationMetadata.begin(); _iter232 != this->creationMetadata.end(); ++_iter232) - { - xfer += oprot->writeString(_iter232->first); - xfer += _iter232->second.write(oprot); - } - xfer += oprot->writeMapEnd(); - } + xfer += oprot->writeFieldBegin("creationMetadata", ::apache::thrift::protocol::T_STRUCT, 16); + xfer += this->creationMetadata.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -5273,43 +5249,43 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other233) { - tableName = other233.tableName; - dbName = other233.dbName; - owner = other233.owner; - createTime = other233.createTime; - lastAccessTime = other233.lastAccessTime; - retention = other233.retention; - sd = other233.sd; - partitionKeys = other233.partitionKeys; - parameters = other233.parameters; - viewOriginalText = other233.viewOriginalText; - viewExpandedText = other233.viewExpandedText; - tableType = other233.tableType; - privileges = other233.privileges; - temporary = other233.temporary; - rewriteEnabled = other233.rewriteEnabled; - creationMetadata = other233.creationMetadata; - __isset = other233.__isset; -} -Table& Table::operator=(const Table& other234) { - tableName = other234.tableName; - dbName = other234.dbName; - owner = other234.owner; - createTime = other234.createTime; - lastAccessTime = other234.lastAccessTime; - retention = other234.retention; - sd = other234.sd; - partitionKeys = other234.partitionKeys; - parameters = other234.parameters; - viewOriginalText = other234.viewOriginalText; - viewExpandedText = other234.viewExpandedText; - tableType = other234.tableType; - privileges = other234.privileges; - temporary = other234.temporary; - rewriteEnabled = other234.rewriteEnabled; - creationMetadata = other234.creationMetadata; - __isset = other234.__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) { + tableName = other226.tableName; + dbName = other226.dbName; + owner = other226.owner; + createTime = other226.createTime; + lastAccessTime = other226.lastAccessTime; + retention = other226.retention; + sd = other226.sd; + partitionKeys = other226.partitionKeys; + parameters = other226.parameters; + viewOriginalText = other226.viewOriginalText; + viewExpandedText = other226.viewExpandedText; + tableType = other226.tableType; + privileges = other226.privileges; + temporary = other226.temporary; + rewriteEnabled = other226.rewriteEnabled; + creationMetadata = other226.creationMetadata; + __isset = other226.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -5397,14 +5373,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size235; - ::apache::thrift::protocol::TType _etype238; - xfer += iprot->readListBegin(_etype238, _size235); - this->values.resize(_size235); - uint32_t _i239; - for (_i239 = 0; _i239 < _size235; ++_i239) + 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[_i239]); + xfer += iprot->readString(this->values[_i231]); } xfer += iprot->readListEnd(); } @@ -5457,17 +5433,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size240; - ::apache::thrift::protocol::TType _ktype241; - ::apache::thrift::protocol::TType _vtype242; - xfer += iprot->readMapBegin(_ktype241, _vtype242, _size240); - uint32_t _i244; - for (_i244 = 0; _i244 < _size240; ++_i244) + 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 _key245; - xfer += iprot->readString(_key245); - std::string& _val246 = this->parameters[_key245]; - xfer += iprot->readString(_val246); + std::string _key237; + xfer += iprot->readString(_key237); + std::string& _val238 = this->parameters[_key237]; + xfer += iprot->readString(_val238); } xfer += iprot->readMapEnd(); } @@ -5504,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 _iter247; - for (_iter247 = this->values.begin(); _iter247 != this->values.end(); ++_iter247) + std::vector<std::string> ::const_iterator _iter239; + for (_iter239 = this->values.begin(); _iter239 != this->values.end(); ++_iter239) { - xfer += oprot->writeString((*_iter247)); + xfer += oprot->writeString((*_iter239)); } xfer += oprot->writeListEnd(); } @@ -5536,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 _iter248; - for (_iter248 = this->parameters.begin(); _iter248 != this->parameters.end(); ++_iter248) + std::map<std::string, std::string> ::const_iterator _iter240; + for (_iter240 = this->parameters.begin(); _iter240 != this->parameters.end(); ++_iter240) { - xfer += oprot->writeString(_iter248->first); - xfer += oprot->writeString(_iter248->second); + xfer += oprot->writeString(_iter240->first); + xfer += oprot->writeString(_iter240->second); } xfer += oprot->writeMapEnd(); } @@ -5569,27 +5545,27 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other249) { - values = other249.values; - dbName = other249.dbName; - tableName = other249.tableName; - createTime = other249.createTime; - lastAccessTime = other249.lastAccessTime; - sd = other249.sd; - parameters = other249.parameters; - privileges = other249.privileges; - __isset = other249.__isset; -} -Partition& Partition::operator=(const Partition& other250) { - values = other250.values; - dbName = other250.dbName; - tableName = other250.tableName; - createTime = other250.createTime; - lastAccessTime = other250.lastAccessTime; - sd = other250.sd; - parameters = other250.parameters; - privileges = other250.privileges; - __isset = other250.__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) { + values = other242.values; + dbName = other242.dbName; + tableName = other242.tableName; + createTime = other242.createTime; + lastAccessTime = other242.lastAccessTime; + sd = other242.sd; + parameters = other242.parameters; + privileges = other242.privileges; + __isset = other242.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5661,14 +5637,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size251; - ::apache::thrift::protocol::TType _etype254; - xfer += iprot->readListBegin(_etype254, _size251); - this->values.resize(_size251); - uint32_t _i255; - for (_i255 = 0; _i255 < _size251; ++_i255) + 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[_i255]); + xfer += iprot->readString(this->values[_i247]); } xfer += iprot->readListEnd(); } @@ -5705,17 +5681,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size256; - ::apache::thrift::protocol::TType _ktype257; - ::apache::thrift::protocol::TType _vtype258; - xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256); - uint32_t _i260; - for (_i260 = 0; _i260 < _size256; ++_i260) + 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 _key261; - xfer += iprot->readString(_key261); - std::string& _val262 = this->parameters[_key261]; - xfer += iprot->readString(_val262); + std::string _key253; + xfer += iprot->readString(_key253); + std::string& _val254 = this->parameters[_key253]; + xfer += iprot->readString(_val254); } xfer += iprot->readMapEnd(); } @@ -5752,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 _iter263; - for (_iter263 = this->values.begin(); _iter263 != this->values.end(); ++_iter263) + std::vector<std::string> ::const_iterator _iter255; + for (_iter255 = this->values.begin(); _iter255 != this->values.end(); ++_iter255) { - xfer += oprot->writeString((*_iter263)); + xfer += oprot->writeString((*_iter255)); } xfer += oprot->writeListEnd(); } @@ -5776,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 _iter264; - for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264) + std::map<std::string, std::string> ::const_iterator _iter256; + for (_iter256 = this->parameters.begin(); _iter256 != this->parameters.end(); ++_iter256) { - xfer += oprot->writeString(_iter264->first); - xfer += oprot->writeString(_iter264->second); + xfer += oprot->writeString(_iter256->first); + xfer += oprot->writeString(_iter256->second); } xfer += oprot->writeMapEnd(); } @@ -5807,23 +5783,23 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other265) { - values = other265.values; - createTime = other265.createTime; - lastAccessTime = other265.lastAccessTime; - relativePath = other265.relativePath; - parameters = other265.parameters; - privileges = other265.privileges; - __isset = other265.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other266) { - values = other266.values; - createTime = other266.createTime; - lastAccessTime = other266.lastAccessTime; - relativePath = other266.relativePath; - parameters = other266.parameters; - privileges = other266.privileges; - __isset = other266.__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) { + values = other258.values; + createTime = other258.createTime; + lastAccessTime = other258.lastAccessTime; + relativePath = other258.relativePath; + parameters = other258.parameters; + privileges = other258.privileges; + __isset = other258.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5876,14 +5852,14 @@ uint32_t PartitionSpecWithSharedSD::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 _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[_i271].read(iprot); + xfer += this->partitions[_i263].read(iprot); } xfer += iprot->readListEnd(); } @@ -5920,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 _iter272; - for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) + std::vector<PartitionWithoutSD> ::const_iterator _iter264; + for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264) { - xfer += (*_iter272).write(oprot); + xfer += (*_iter264).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5945,15 +5921,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other273) { - partitions = other273.partitions; - sd = other273.sd; - __isset = other273.__isset; +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other265) { + partitions = other265.partitions; + sd = other265.sd; + __isset = other265.__isset; } -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other274) { - partitions = other274.partitions; - sd = other274.sd; - __isset = other274.__isset; +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other266) { + partitions = other266.partitions; + sd = other266.sd; + __isset = other266.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5998,14 +5974,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size275; - ::apache::thrift::protocol::TType _etype278; - xfer += iprot->readListBegin(_etype278, _size275); - this->partitions.resize(_size275); - uint32_t _i279; - for (_i279 = 0; _i279 < _size275; ++_i279) + 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[_i279].read(iprot); + xfer += this->partitions[_i271].read(iprot); } xfer += iprot->readListEnd(); } @@ -6034,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 _iter280; - for (_iter280 = this->partitions.begin(); _iter280 != this->partitions.end(); ++_iter280) + std::vector<Partition> ::const_iterator _iter272; + for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) { - xfer += (*_iter280).write(oprot); + xfer += (*_iter272).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6054,13 +6030,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other281) { - partitions = other281.partitions; - __isset = other281.__isset; +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other273) { + partitions = other273.partitions; + __isset = other273.__isset; } -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other282) { - partitions = other282.partitions; - __isset = other282.__isset; +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other274) { + partitions = other274.partitions; + __isset = other274.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -6212,21 +6188,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other283) { - dbName = other283.dbName; - tableName = other283.tableName; - rootPath = other283.rootPath; - sharedSDPartitionSpec = other283.sharedSDPartitionSpec; - partitionList = other283.partitionList; - __isset = other283.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other284) { - dbName = other284.dbName; - tableName = other284.tableName; - rootPath = other284.rootPath; - sharedSDPartitionSpec = other284.sharedSDPartitionSpec; - partitionList = other284.partitionList; - __isset = other284.__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) { + dbName = other276.dbName; + tableName = other276.tableName; + rootPath = other276.rootPath; + sharedSDPartitionSpec = other276.sharedSDPartitionSpec; + partitionList = other276.partitionList; + __isset = other276.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -6374,17 +6350,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size285; - ::apache::thrift::protocol::TType _ktype286; - ::apache::thrift::protocol::TType _vtype287; - xfer += iprot->readMapBegin(_ktype286, _vtype287, _size285); - uint32_t _i289; - for (_i289 = 0; _i289 < _size285; ++_i289) + 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 _key290; - xfer += iprot->readString(_key290); - std::string& _val291 = this->parameters[_key290]; - xfer += iprot->readString(_val291); + std::string _key282; + xfer += iprot->readString(_key282); + std::string& _val283 = this->parameters[_key282]; + xfer += iprot->readString(_val283); } xfer += iprot->readMapEnd(); } @@ -6453,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 _iter292; - for (_iter292 = this->parameters.begin(); _iter292 != this->parameters.end(); ++_iter292) + std::map<std::string, std::string> ::const_iterator _iter284; + for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284) { - xfer += oprot->writeString(_iter292->first); - xfer += oprot->writeString(_iter292->second); + xfer += oprot->writeString(_iter284->first); + xfer += oprot->writeString(_iter284->second); } xfer += oprot->writeMapEnd(); } @@ -6487,31 +6463,31 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other293) { - indexName = other293.indexName; - indexHandlerClass = other293.indexHandlerClass; - dbName = other293.dbName; - origTableName = other293.origTableName; - createTime = other293.createTime; - lastAccessTime = other293.lastAccessTime; - indexTableName = other293.indexTableName; - sd = other293.sd; - parameters = other293.parameters; - deferredRebuild = other293.deferredRebuild; - __isset = other293.__isset; -} -Index& Index::operator=(const Index& other294) { - indexName = other294.indexName; - indexHandlerClass = other294.indexHandlerClass; - dbName = other294.dbName; - origTableName = other294.origTableName; - createTime = other294.createTime; - lastAccessTime = other294.lastAccessTime; - indexTableName = other294.indexTableName; - sd = other294.sd; - parameters = other294.parameters; - deferredRebuild = other294.deferredRebuild; - __isset = other294.__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) { + indexName = other286.indexName; + indexHandlerClass = other286.indexHandlerClass; + dbName = other286.dbName; + origTableName = other286.origTableName; + createTime = other286.createTime; + lastAccessTime = other286.lastAccessTime; + indexTableName = other286.indexTableName; + sd = other286.sd; + parameters = other286.parameters; + deferredRebuild = other286.deferredRebuild; + __isset = other286.__isset; return *this; } void Index::printTo(std::ostream& out) const { @@ -6662,19 +6638,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other295) { - numTrues = other295.numTrues; - numFalses = other295.numFalses; - numNulls = other295.numNulls; - bitVectors = other295.bitVectors; - __isset = other295.__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& other296) { - numTrues = other296.numTrues; - numFalses = other296.numFalses; - numNulls = other296.numNulls; - bitVectors = other296.bitVectors; - __isset = other296.__isset; +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other288) { + numTrues = other288.numTrues; + numFalses = other288.numFalses; + numNulls = other288.numNulls; + bitVectors = other288.bitVectors; + __isset = other288.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6837,21 +6813,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other297) { - lowValue = other297.lowValue; - highValue = other297.highValue; - numNulls = other297.numNulls; - numDVs = other297.numDVs; - bitVectors = other297.bitVectors; - __isset = other297.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other298) { - lowValue = other298.lowValue; - highValue = other298.highValue; - numNulls = other298.numNulls; - numDVs = other298.numDVs; - bitVectors = other298.bitVectors; - __isset = other298.__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) { + lowValue = other290.lowValue; + highValue = other290.highValue; + numNulls = other290.numNulls; + numDVs = other290.numDVs; + bitVectors = other290.bitVectors; + __isset = other290.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -7015,21 +6991,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other300) { - lowValue = other300.lowValue; - highValue = other300.highValue; - numNulls = other300.numNulls; - numDVs = other300.numDVs; - bitVectors = other300.bitVectors; - __isset = other300.__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) { + lowValue = other292.lowValue; + highValue = other292.highValue; + numNulls = other292.numNulls; + numDVs = other292.numDVs; + bitVectors = other292.bitVectors; + __isset = other292.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7195,21 +7171,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other301) { - maxColLen = other301.maxColLen; - avgColLen = other301.avgColLen; - numNulls = other301.numNulls; - numDVs = other301.numDVs; - bitVectors = other301.bitVectors; - __isset = other301.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other302) { - maxColLen = other302.maxColLen; - avgColLen = other302.avgColLen; - numNulls = other302.numNulls; - numDVs = other302.numDVs; - bitVectors = other302.bitVectors; - __isset = other302.__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) { + maxColLen = other294.maxColLen; + avgColLen = other294.avgColLen; + numNulls = other294.numNulls; + numDVs = other294.numDVs; + bitVectors = other294.bitVectors; + __isset = other294.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7355,19 +7331,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other303) { - maxColLen = other303.maxColLen; - avgColLen = other303.avgColLen; - numNulls = other303.numNulls; - bitVectors = other303.bitVectors; - __isset = other303.__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& other304) { - maxColLen = other304.maxColLen; - avgColLen = other304.avgColLen; - numNulls = other304.numNulls; - bitVectors = other304.bitVectors; - __isset = other304.__isset; +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other296) { + maxColLen = other296.maxColLen; + avgColLen = other296.avgColLen; + numNulls = other296.numNulls; + bitVectors = other296.bitVectors; + __isset = other296.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7472,13 +7448,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other305) { - unscaled = other305.unscaled; - scale = other305.scale; +Decimal::Decimal(const Decimal& other297) { + unscaled = other297.unscaled; + scale = other297.scale; } -Decimal& Decimal::operator=(const Decimal& other306) { - unscaled = other306.unscaled; - scale = other306.scale; +Decimal& Decimal::operator=(const Decimal& other298) { + unscaled = other298.unscaled; + scale = other298.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7639,21 +7615,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other307) { - lowValue = other307.lowValue; - highValue = other307.highValue; - numNulls = other307.numNulls; - numDVs = other307.numDVs; - bitVectors = other307.bitVectors; - __isset = other307.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other308) { - lowValue = other308.lowValue; - highValue = other308.highValue; - numNulls = other308.numNulls; - numDVs = other308.numDVs; - bitVectors = other308.bitVectors; - __isset = other308.__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) { + lowValue = other300.lowValue; + highValue = other300.highValue; + numNulls = other300.numNulls; + numDVs = other300.numDVs; + bitVectors = other300.bitVectors; + __isset = other300.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7739,11 +7715,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other309) { - daysSinceEpoch = other309.daysSinceEpoch; +Date::Date(const Date& other301) { + daysSinceEpoch = other301.daysSinceEpoch; } -Date& Date::operator=(const Date& other310) { - daysSinceEpoch = other310.daysSinceEpoch; +Date& Date::operator=(const Date& other302) { + daysSinceEpoch = other302.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7903,21 +7879,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other311) { - lowValue = other311.lowValue; - highValue = other311.highValue; - numNulls = other311.numNulls; - numDVs = other311.numDVs; - bitVectors = other311.bitVectors; - __isset = other311.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other312) { - lowValue = other312.lowValue; - highValue = other312.highValue; - numNulls = other312.numNulls; - numDVs = other312.numDVs; - bitVectors = other312.bitVectors; - __isset = other312.__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) { + lowValue = other304.lowValue; + highValue = other304.highValue; + numNulls = other304.numNulls; + numDVs = other304.numDVs; + bitVectors = other304.bitVectors; + __isset = other304.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8103,25 +8079,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other313) { - booleanStats = other313.booleanStats; - longStats = other313.longStats; - doubleStats = other313.doubleStats; - stringStats = other313.stringStats; - binaryStats = other313.binaryStats; - decimalStats = other313.decimalStats; - dateStats = other313.dateStats; - __isset = other313.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other314) { - booleanStats = other314.booleanStats; - longStats = other314.longStats; - doubleStats = other314.doubleStats; - stringStats = other314.stringStats; - binaryStats = other314.binaryStats; - decimalStats = other314.decimalStats; - dateStats = other314.dateStats; - __isset = other314.__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) { + booleanStats = other306.booleanStats; + longStats = other306.longStats; + doubleStats = other306.doubleStats; + stringStats = other306.stringStats; + binaryStats = other306.binaryStats; + decimalStats = other306.decimalStats; + dateStats = other306.dateStats; + __isset = other306.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8249,15 +8225,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other315) { - colName = other315.colName; - colType = other315.colType; - statsData = other315.statsData; +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) { + colName = other307.colName; + colType = other307.colType; + statsData = other307.statsData; } -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other316) { - colName = other316.colName; - colType = other316.colType; - statsData = other316.statsData; +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other308) { + colName = other308.colName; + colType = other308.colType; + statsData = other308.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8420,21 +8396,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other317) { - isTblLevel = other317.isTblLevel; - dbName = other317.dbName; - tableName = other317.tableName; - partName = other317.partName; - lastAnalyzed = other317.lastAnalyzed; - __isset = other317.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other318) { - isTblLevel = other318.isTblLevel; - dbName = other318.dbName; - tableName = other318.tableName; - partName = other318.partName; - lastAnalyzed = other318.lastAnalyzed; - __isset = other318.__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) { + isTblLevel = other310.isTblLevel; + dbName = other310.dbName; + tableName = other310.tableName; + partName = other310.partName; + lastAnalyzed = other310.lastAnalyzed; + __isset = other310.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8496,14 +8472,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size319; - ::apache::thrift::protocol::TType _etype322; - xfer += iprot->readListBegin(_etype322, _size319); - this->statsObj.resize(_size319); - uint32_t _i323; - for (_i323 = 0; _i323 < _size319; ++_i323) + 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[_i323].read(iprot); + xfer += this->statsObj[_i315].read(iprot); } xfer += iprot->readListEnd(); } @@ -8540,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 _iter324; - for (_iter324 = this->statsObj.begin(); _iter324 != this->statsObj.end(); ++_iter324) + std::vector<ColumnStatisticsObj> ::const_iterator _iter316; + for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); ++_iter316) { - xfer += (*_iter324).write(oprot); + xfer += (*_iter316).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8560,13 +8536,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other325) { - statsDesc = other325.statsDesc; - statsObj = other325.statsObj; +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) { + statsDesc = other317.statsDesc; + statsObj = other317.statsObj; } -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other326) { - statsDesc = other326.statsDesc; - statsObj = other326.statsObj; +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other318) { + statsDesc = other318.statsDesc; + statsObj = other318.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8617,14 +8593,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { 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 _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[_i331].read(iprot); + xfer += this->colStats[_i323].read(iprot); } xfer += iprot->readListEnd(); } @@ -8665,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 _iter332; - for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) + std::vector<ColumnStatisticsObj> ::const_iterator _iter324; + for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) { - xfer += (*_iter332).write(oprot); + xfer += (*_iter324).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8689,13 +8665,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other333) { - colStats = other333.colStats; - partsFound = other333.partsFound; +AggrStats::AggrStats(const AggrStats& other325) { + colStats = other325.colStats; + partsFound = other325.partsFound; } -AggrStats& AggrStats::operator=(const AggrStats& other334) { - colStats = other334.colStats; - partsFound = other334.partsFound; +AggrStats& AggrStats::operator=(const AggrStats& other326) { + colStats = other326.colStats; + partsFound = other326.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8746,14 +8722,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size335; - ::apache::thrift::protocol::TType _etype338; - xfer += iprot->readListBegin(_etype338, _size335); - this->colStats.resize(_size335); - uint32_t _i339; - for (_i339 = 0; _i339 < _size335; ++_i339) + 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[_i339].read(iprot); + xfer += this->colStats[_i331].read(iprot); } xfer += iprot->readListEnd(); } @@ -8792,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 _iter340; - for (_iter340 = this->colStats.begin(); _iter340 != this->colStats.end(); ++_iter340) + std::vector<ColumnStatistics> ::const_iterator _iter332; + for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) { - xfer += (*_iter340).write(oprot); + xfer += (*_iter332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8818,15 +8794,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other341) { - colStats = other341.colStats; - needMerge = other341.needMerge; - __isset = other341.__isset; +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other333) { + colStats = other333.colStats; + needMerge = other333.needMerge; + __isset = other333.__isset; } -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other342) { - colStats = other342.colStats; - needMerge = other342.needMerge; - __isset = other342.__isset; +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other334) { + colStats = other334.colStats; + needMerge = other334.needMerge; + __isset = other334.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8875,14 +8851,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size343; - ::apache::thrift::protocol::TType _etype346; - xfer += iprot->readListBegin(_etype346, _size343); - this->fieldSchemas.resize(_size343); - uint32_t _i347; - for (_i347 = 0; _i347 < _size343; ++_i347) + 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[_i347].read(iprot); + xfer += this->fieldSchemas[_i339].read(iprot); } xfer += iprot->readListEnd(); } @@ -8895,17 +8871,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size348; - ::apache::thrift::protocol::TType _ktype349; - ::apache::thrift::protocol::TType _vtype350; - xfer += iprot->readMapBegin(_ktype349, _vtype350, _size348); - uint32_t _i352; - for (_i352 = 0; _i352 < _size348; ++_i352) + 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 _key353; - xfer += iprot->readString(_key353); - std::string& _val354 = this->properties[_key353]; - xfer += iprot->readString(_val354); + std::string _key345; + xfer += iprot->readString(_key345); + std::string& _val346 = this->properties[_key345]; + xfer += iprot->readString(_val346); } xfer += iprot->readMapEnd(); } @@ -8934,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 _iter355; - for (_iter355 = this->fieldSchemas.begin(); _iter355 != this->fieldSchemas.end(); ++_iter355) + std::vector<FieldSchema> ::const_iterator _iter347; + for (_iter347 = this->fieldSchemas.begin(); _iter347 != this->fieldSchemas.end(); ++_iter347) { - xfer += (*_iter355).write(oprot); + xfer += (*_iter347).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8946,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 _iter356; - for (_iter356 = this->properties.begin(); _iter356 != this->properties.end(); ++_iter356) + std::map<std::string, std::string> ::const_iterator _iter348; + for (_iter348 = this->properties.begin(); _iter348 != this->properties.end(); ++_iter348) { - xfer += oprot->writeString(_iter356->first); - xfer += oprot->writeString(_iter356->second); + xfer += oprot->writeString(_iter348->first); + xfer += oprot->writeString(_iter348->second); } xfer += oprot->writeMapEnd(); } @@ -8968,15 +8944,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other357) { - fieldSchemas = other357.fieldSchemas; - properties = other357.properties; - __isset = other357.__isset; +Schema::Schema(const Schema& other349) { + fieldSchemas = other349.fieldSchemas; + properties = other349.properties; + __isset = other349.__isset; } -Schema& Schema::operator=(const Schema& other358) { - fieldSchemas = other358.fieldSchemas; - properties = other358.properties; - __isset = other358.__isset; +Schema& Schema::operator=(const Schema& other350) { + fieldSchemas = other350.fieldSchemas; + properties = other350.properties; + __isset = other350.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -9021,17 +8997,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _ktype360; - ::apache::thrift::protocol::TType _vtype361; - xfer += iprot->readMapBegin(_ktype360, _vtype361, _size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + 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 _key364; - xfer += iprot->readString(_key364); - std::string& _val365 = this->properties[_key364]; - xfer += iprot->readString(_val365); + std::string _key356; + xfer += iprot->readString(_key356); + std::string& _val357 = this->properties[_key356]; + xfer += iprot->readString(_val357); } xfer += iprot->readMapEnd(); } @@ -9060,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 _iter366; - for (_iter366 = this->properties.begin(); _iter366 != this->properties.end(); ++_iter366) + std::map<std::string, std::string> ::const_iterator _iter358; + for (_iter358 = this->properties.begin(); _iter358 != this->properties.end(); ++_iter358) { - xfer += oprot->writeString(_iter366->first); - xfer += oprot->writeString(_iter366->second); + xfer += oprot->writeString(_iter358->first); + xfer += oprot->writeString(_iter358->second); } xfer += oprot->writeMapEnd(); } @@ -9081,13 +9057,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other367) { - properties = other367.properties; - __isset = other367.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) { + properties = other359.properties; + __isset = other359.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other368) { - properties = other368.properties; - __isset = other368.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other360) { + properties = other360.properties; + __isset = other360.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9189,13 +9165,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other369) { - db_name = other369.db_name; - tbl_name = other369.tbl_name; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) { + db_name = other361.db_name; + tbl_name = other361.tbl_name; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other370) { - db_name = other370.db_name; - tbl_name = other370.tbl_name; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other362) { + db_name = other362.db_name; + tbl_name = other362.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9241,14 +9217,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size371; - ::apache::thrift::protocol::TType _etype374; - xfer += iprot->readListBegin(_etype374, _size371); - this->primaryKeys.resize(_size371); - uint32_t _i375; - for (_i375 = 0; _i375 < _size371; ++_i375) + 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[_i375].read(iprot); + xfer += this->primaryKeys[_i367].read(iprot); } xfer += iprot->readListEnd(); } @@ -9279,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 _iter376; - for (_iter376 = this->primaryKeys.begin(); _iter376 != this->primaryKeys.end(); ++_iter376) + std::vector<SQLPrimaryKey> ::const_iterator _iter368; + for (_iter368 = this->primaryKeys.begin(); _iter368 != this->primaryKeys.end(); ++_iter368) { - xfer += (*_iter376).write(oprot); + xfer += (*_iter368).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9298,11 +9274,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other377) { - primaryKeys = other377.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) { + primaryKeys = other369.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other378) { - primaryKeys = other378.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other370) { + primaryKeys = other370.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9433,19 +9409,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other379) { - parent_db_name = other379.parent_db_name; - parent_tbl_name = other379.parent_tbl_name; - foreign_db_name = other379.foreign_db_name; - foreign_tbl_name = other379.foreign_tbl_name; - __isset = other379.__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& other380) { - parent_db_name = other380.parent_db_name; - parent_tbl_name = other380.parent_tbl_name; - foreign_db_name = other380.foreign_db_name; - foreign_tbl_name = other380.foreign_tbl_name; - __isset = other380.__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; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -9493,14 +9469,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size381; - ::apache::thrift::protocol::TType _etype384; - xfer += iprot->readListBegin(_etype384, _size381); - this->foreignKeys.resize(_size381); - uint32_t _i385; - for (_i385 = 0; _i385 < _size381; ++_i385) + 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[_i385].read(iprot); + xfer += this->foreignKeys[_i377].read(iprot); } xfer += iprot->readListEnd(); } @@ -9531,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 _iter386; - for (_iter386 = this->foreignKeys.begin(); _iter386 != this->foreignKeys.end(); ++_iter386) + std::vector<SQLForeignKey> ::const_iterator _iter378; + for (_iter378 = this->foreignKeys.begin(); _iter378 != this->foreignKeys.end(); ++_iter378) { - xfer += (*_iter386).write(oprot); + xfer += (*_iter378).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9550,11 +9526,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other387) { - foreignKeys = other387.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other379) { + foreignKeys = other379.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other388) { - foreignKeys = other388.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other380) { + foreignKeys = other380.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9656,13 +9632,13 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other389) { - db_name = other389.db_name; - tbl_name = other389.tbl_name; +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other381) { + db_name = other381.db_name; + tbl_name = other381.tbl_name; } -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other390) { - db_name = other390.db_name; - tbl_name = other390.tbl_name; +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other382) { + db_name = other382.db_name; + tbl_name = other382.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -9708,14 +9684,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size391; - ::apache::thrift::protocol::TType _etype394; - xfer += iprot->readListBegin(_etype394, _size391); - this->uniqueConstraints.resize(_size391); - uint32_t _i395; - for (_i395 = 0; _i395 < _size391; ++_i395) + 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[_i395].read(iprot); + xfer += this->uniqueConstraints[_i387].read(iprot); } xfer += iprot->readListEnd(); } @@ -9746,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 _iter396; - for (_iter396 = this->uniqueConstraints.begin(); _iter396 != this->uniqueConstraints.end(); ++_iter396) + std::vector<SQLUniqueConstraint> ::const_iterator _iter388; + for (_iter388 = this->uniqueConstraints.begin(); _iter388 != this->uniqueConstraints.end(); ++_iter388) { - xfer += (*_iter396).write(oprot); + xfer += (*_iter388).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9765,11 +9741,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other397) { - uniqueConstraints = other397.uniqueConstraints; +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other389) { + uniqueConstraints = other389.uniqueConstraints; } -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other398) { - uniqueConstraints = other398.uniqueConstraints; +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other390) { + uniqueConstraints = other390.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -9871,13 +9847,13 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other399) { - db_name = other399.db_name; - tbl_name = other399.tbl_name; +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other391) { + db_name = other391.db_name; + tbl_name = other391.tbl_name; } -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other400) { - db_name = other400.db_name; - tbl_name = other400.tbl_name; +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other392) { + db_name = other392.db_name; + tbl_name = other392.tbl_name; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -9923,14 +9899,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size401; - ::apache::thrift::protocol::TType _etype404; - xfer += iprot->readListBegin(_etype404, _size401); - this->notNullConstraints.resize(_size401); - uint32_t _i405; - for (_i405 = 0; _i405 < _size401; ++_i405) + 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[_i405].read(iprot); + xfer += this->notNullConstraints[_i397].read(iprot); } xfer += iprot->readListEnd(); } @@ -9961,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 _iter406; - for (_iter406 = this->notNullConstraints.begin(); _iter406 != this->notNullConstraints.end(); ++_iter406) + std::vector<SQLNotNullConstraint> ::const_iterator _iter398; + for (_iter398 = this->notNullConstraints.begin(); _iter398 != this->notNullConstraints.end(); ++_iter398) { - xfer += (*_iter406).write(oprot); + xfer += (*_iter398).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9980,11 +9956,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other407) { - notNullConstraints = other407.notNullConstraints; +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other399) { + notNullConstraints = other399.notNullConstraints; } -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other408) { - notNullConstraints = other408.notNullConstraints; +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other400) { + notNullConstraints = other400.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -10106,15 +10082,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other409) { - dbname = other409.dbname; - tablename = other409.tablename; - constraintname = other409.constraintname; +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other401) { + dbname = other401.dbname; + tablename = other401.tablename; + constraintname = other401.constraintname; } -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other410) { - dbname = other410.dbname; - tablename = other410.tablename; - constraintname = other410.constraintname; +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other402) { + dbname = other402.dbname; + tablename = other402.tablename; + constraintname = other402.constraintname; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -10161,14 +10137,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size411; - ::apache::thrift::protocol::TType _etype414; - xfer += iprot->readListBegin(_etype414, _size411); - this->primaryKeyCols.resize(_size411); - uint32_t _i415; - for (_i415 = 0; _i415 < _size411; ++_i415) + 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[_i415].read(iprot); + xfer += this->primaryKeyCols[_i407].read(iprot); } xfer += iprot->readListEnd(); } @@ -10199,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 _iter416; - for (_iter416 = this->primaryKeyCols.begin(); _iter416 != this->primaryKeyCols.end(); ++_iter416) + std::vector<SQLPrimaryKey> ::const_iterator _iter408; + for (_iter408 = this->primaryKeyCols.begin(); _iter408 != this->primaryKeyCols.end(); ++_iter408) { - xfer += (*_iter416).write(oprot); + xfer += (*_iter408).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10218,11 +10194,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other417) { - primaryKeyCols = other417.primaryKeyCols; +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other409) { + primaryKeyCols = other409.primaryKeyCols; } -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other418) { - primaryKeyCols = other418.primaryKeyCols; +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other410) { + primaryKeyCols = other410.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -10267,14 +10243,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size419; - ::apache::thrift::protocol::TType _etype422; - xfer += iprot->readListBegin(_etype422, _size419); - this->foreignKeyCols.resize(_size419); - uint32_t _i423; - for (_i423 = 0; _i423 < _size419; ++_i423) + 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[_i423].read(iprot); + xfer += this->foreignKeyCols[_i415].read(iprot); } xfer += iprot->readListEnd(); } @@ -10305,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 _iter424; - for (_iter424 = this->foreignKeyCols.begin(); _iter424 != this->foreignKeyCols.end(); ++_iter424) + std::vector<SQLForeignKey> ::const_iterator _iter416; + for (_iter416 = this->foreignKeyCols.begin(); _iter416 != this->foreignKeyCols.end(); ++_iter416) { - xfer += (*_iter424).write(oprot); + xfer += (*_iter416).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10324,11 +10300,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other425) { - foreignKeyCols = other425.foreignKeyCols; +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other417) { + foreignKeyCols = other417.foreignKeyCols; } -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other426) { - foreignKeyCols = other426.foreignKeyCols; +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other418) { + foreignKeyCols = other418.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -10373,14 +10349,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - uint32_t _size427; - ::apache::thrift::protocol::TType _etype430; - xfer += iprot->readListBegin(_etype430, _size427); - this->uniqueConstraintCols.resize(_size427); - uint32_t _i431; - for (_i431 = 0; _i431 < _size427; ++_i431) + 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[_i431].read(iprot); + xfer += this->uniqueConstraintCols[_i423].read(iprot); } xfer += iprot->readListEnd(); } @@ -10411,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 _iter432; - for (_iter432 = this->uniqueConstraintCols.begin(); _iter432 != this->uniqueConstraintCols.end(); ++_iter432) + std::vector<SQLUniqueConstraint> ::const_iterator _iter424; + for (_iter424 = this->uniqueConstraintCols.begin(); _iter424 != this->uniqueConstraintCols.end(); ++_iter424) { - xfer += (*_iter432).write(oprot); + xfer += (*_iter424).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10430,11 +10406,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other433) { - uniqueConstraintCols = other433.uniqueConstraintCols; +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other425) { + uniqueConstraintCols = other425.uniqueConstraintCols; } -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other434) { - uniqueConstraintCols = other434.uniqueConstraintCols; +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other426) { + uniqueConstraintCols = other426.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -10479,14 +10455,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - uint32_t _size435; - ::apache::thrift::protocol::TType _etype438; - xfer += iprot->readListBegin(_etype438, _size435); - this->notNullConstraintCols.resize(_size435); - uint32_t _i439; - for (_i439 = 0; _i439 < _size435; ++_i439) + 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[_i439].read(iprot); + xfer += this->notNullConstraintCols[_i431].read(iprot); } xfer += iprot->readListEnd(); } @@ -10517,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 _iter440; - for (_iter440 = this->notNullConstraintCols.begin(); _iter440 != this->notNullConstraintCols.end(); ++_iter440) + std::vector<SQLNotNullConstraint> ::const_iterator _iter432; + for (_iter432 = this->notNullConstraintCols.begin(); _iter432 != this->notNullConstraintCols.end(); ++_iter432) { - xfer += (*_iter440).write(oprot); + xfer += (*_iter432).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10536,11 +10512,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other441) { - notNullConstraintCols = other441.notNullConstraintCols; +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other433) { + notNullConstraintCols = other433.notNullConstraintCols; } -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other442) { - notNullConstraintCols = other442.notNullConstraintCols; +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other434) { + notNullConstraintCols = other434.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -10590,14 +10566,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size443; - ::apache::thrift::protocol::TType _etype446; - xfer += iprot->readListBegin(_etype446, _size443); - this->partitions.resize(_size443); - uint32_t _i447; - for (_i447 = 0; _i447 < _size443; ++_i447) + 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[_i447].read(iprot); + xfer += this->partitions[_i439].read(iprot); } xfer += iprot->readListEnd(); } @@ -10638,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 _iter448; - for (_iter448 = this->partitions.begin(); _iter448 != this->partitions.end(); ++_iter448) + std::vector<Partition> ::const_iterator _iter440; + for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) { - xfer += (*_iter448).write(oprot); + xfer += (*_iter440).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10662,13 +10638,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other449) { - partitions = other449.partitions; - hasUnknownPartitions = other449.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other441) { + partitions = other441.partitions; + hasUnknownPartitions = other441.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other450) { - partitions = other450.partitions; - hasUnknownPartitions = other450.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other442) { + partitions = other442.partitions; + hasUnknownPartitions = other442.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -10830,21 +10806,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other451) { - dbName = other451.dbName; - tblName = other451.tblName; - expr = other451.expr; - defaultPartitionName = other451.defaultPartitionName; - maxParts = other451.maxParts;
<TRUNCATED>
