http://git-wip-us.apache.org/repos/asf/hive/blob/1d46608e/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 bc4d168..c2d6a56 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 @@ -215,6 +215,18 @@ const char* _kSchemaVersionStateNames[] = { }; const std::map<int, const char*> _SchemaVersionState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kSchemaVersionStateValues, _kSchemaVersionStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +int _kIsolationLevelComplianceValues[] = { + IsolationLevelCompliance::YES, + IsolationLevelCompliance::NO, + IsolationLevelCompliance::UNKNOWN +}; +const char* _kIsolationLevelComplianceNames[] = { + "YES", + "NO", + "UNKNOWN" +}; +const std::map<int, const char*> _IsolationLevelCompliance_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kIsolationLevelComplianceValues, _kIsolationLevelComplianceNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + int _kFunctionTypeValues[] = { FunctionType::JAVA }; @@ -6435,6 +6447,21 @@ void Table::__set_ownerType(const PrincipalType::type val) { __isset.ownerType = true; } +void Table::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void Table::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void Table::__set_isStatsCompliant(const IsolationLevelCompliance::type val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -6629,6 +6656,32 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 19: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 20: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 21: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast249; + xfer += iprot->readI32(ecast249); + this->isStatsCompliant = (IsolationLevelCompliance::type)ecast249; + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -6677,10 +6730,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 _iter249; - for (_iter249 = this->partitionKeys.begin(); _iter249 != this->partitionKeys.end(); ++_iter249) + std::vector<FieldSchema> ::const_iterator _iter250; + for (_iter250 = this->partitionKeys.begin(); _iter250 != this->partitionKeys.end(); ++_iter250) { - xfer += (*_iter249).write(oprot); + xfer += (*_iter250).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6689,11 +6742,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 _iter250; - for (_iter250 = this->parameters.begin(); _iter250 != this->parameters.end(); ++_iter250) + std::map<std::string, std::string> ::const_iterator _iter251; + for (_iter251 = this->parameters.begin(); _iter251 != this->parameters.end(); ++_iter251) { - xfer += oprot->writeString(_iter250->first); - xfer += oprot->writeString(_iter250->second); + xfer += oprot->writeString(_iter251->first); + xfer += oprot->writeString(_iter251->second); } xfer += oprot->writeMapEnd(); } @@ -6741,6 +6794,21 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeI32((int32_t)this->ownerType); xfer += oprot->writeFieldEnd(); } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 19); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 20); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_I32, 21); + xfer += oprot->writeI32((int32_t)this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -6766,31 +6834,13 @@ void swap(Table &a, Table &b) { swap(a.creationMetadata, b.creationMetadata); swap(a.catName, b.catName); swap(a.ownerType, b.ownerType); + swap(a.txnId, b.txnId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.isStatsCompliant, b.isStatsCompliant); swap(a.__isset, b.__isset); } -Table::Table(const Table& other251) { - tableName = other251.tableName; - dbName = other251.dbName; - owner = other251.owner; - createTime = other251.createTime; - lastAccessTime = other251.lastAccessTime; - retention = other251.retention; - sd = other251.sd; - partitionKeys = other251.partitionKeys; - parameters = other251.parameters; - viewOriginalText = other251.viewOriginalText; - viewExpandedText = other251.viewExpandedText; - tableType = other251.tableType; - privileges = other251.privileges; - temporary = other251.temporary; - rewriteEnabled = other251.rewriteEnabled; - creationMetadata = other251.creationMetadata; - catName = other251.catName; - ownerType = other251.ownerType; - __isset = other251.__isset; -} -Table& Table::operator=(const Table& other252) { +Table::Table(const Table& other252) { tableName = other252.tableName; dbName = other252.dbName; owner = other252.owner; @@ -6809,7 +6859,34 @@ Table& Table::operator=(const Table& other252) { creationMetadata = other252.creationMetadata; catName = other252.catName; ownerType = other252.ownerType; + txnId = other252.txnId; + validWriteIdList = other252.validWriteIdList; + isStatsCompliant = other252.isStatsCompliant; __isset = other252.__isset; +} +Table& Table::operator=(const Table& other253) { + tableName = other253.tableName; + dbName = other253.dbName; + owner = other253.owner; + createTime = other253.createTime; + lastAccessTime = other253.lastAccessTime; + retention = other253.retention; + sd = other253.sd; + partitionKeys = other253.partitionKeys; + parameters = other253.parameters; + viewOriginalText = other253.viewOriginalText; + viewExpandedText = other253.viewExpandedText; + tableType = other253.tableType; + privileges = other253.privileges; + temporary = other253.temporary; + rewriteEnabled = other253.rewriteEnabled; + creationMetadata = other253.creationMetadata; + catName = other253.catName; + ownerType = other253.ownerType; + txnId = other253.txnId; + validWriteIdList = other253.validWriteIdList; + isStatsCompliant = other253.isStatsCompliant; + __isset = other253.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -6833,6 +6910,9 @@ void Table::printTo(std::ostream& out) const { out << ", " << "creationMetadata="; (__isset.creationMetadata ? (out << to_string(creationMetadata)) : (out << "<null>")); out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "<null>")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "<null>")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "<null>")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "<null>")); out << ")"; } @@ -6879,6 +6959,21 @@ void Partition::__set_catName(const std::string& val) { __isset.catName = true; } +void Partition::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void Partition::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void Partition::__set_isStatsCompliant(const IsolationLevelCompliance::type val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -6904,14 +6999,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size253; - ::apache::thrift::protocol::TType _etype256; - xfer += iprot->readListBegin(_etype256, _size253); - this->values.resize(_size253); - uint32_t _i257; - for (_i257 = 0; _i257 < _size253; ++_i257) + uint32_t _size254; + ::apache::thrift::protocol::TType _etype257; + xfer += iprot->readListBegin(_etype257, _size254); + this->values.resize(_size254); + uint32_t _i258; + for (_i258 = 0; _i258 < _size254; ++_i258) { - xfer += iprot->readString(this->values[_i257]); + xfer += iprot->readString(this->values[_i258]); } xfer += iprot->readListEnd(); } @@ -6964,17 +7059,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size258; - ::apache::thrift::protocol::TType _ktype259; - ::apache::thrift::protocol::TType _vtype260; - xfer += iprot->readMapBegin(_ktype259, _vtype260, _size258); - uint32_t _i262; - for (_i262 = 0; _i262 < _size258; ++_i262) + uint32_t _size259; + ::apache::thrift::protocol::TType _ktype260; + ::apache::thrift::protocol::TType _vtype261; + xfer += iprot->readMapBegin(_ktype260, _vtype261, _size259); + uint32_t _i263; + for (_i263 = 0; _i263 < _size259; ++_i263) { - std::string _key263; - xfer += iprot->readString(_key263); - std::string& _val264 = this->parameters[_key263]; - xfer += iprot->readString(_val264); + std::string _key264; + xfer += iprot->readString(_key264); + std::string& _val265 = this->parameters[_key264]; + xfer += iprot->readString(_val265); } xfer += iprot->readMapEnd(); } @@ -6999,6 +7094,32 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 10: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast266; + xfer += iprot->readI32(ecast266); + this->isStatsCompliant = (IsolationLevelCompliance::type)ecast266; + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -7019,10 +7140,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 _iter265; - for (_iter265 = this->values.begin(); _iter265 != this->values.end(); ++_iter265) + std::vector<std::string> ::const_iterator _iter267; + for (_iter267 = this->values.begin(); _iter267 != this->values.end(); ++_iter267) { - xfer += oprot->writeString((*_iter265)); + xfer += oprot->writeString((*_iter267)); } xfer += oprot->writeListEnd(); } @@ -7051,11 +7172,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 _iter266; - for (_iter266 = this->parameters.begin(); _iter266 != this->parameters.end(); ++_iter266) + std::map<std::string, std::string> ::const_iterator _iter268; + for (_iter268 = this->parameters.begin(); _iter268 != this->parameters.end(); ++_iter268) { - xfer += oprot->writeString(_iter266->first); - xfer += oprot->writeString(_iter266->second); + xfer += oprot->writeString(_iter268->first); + xfer += oprot->writeString(_iter268->second); } xfer += oprot->writeMapEnd(); } @@ -7071,6 +7192,21 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeString(this->catName); xfer += oprot->writeFieldEnd(); } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 10); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_I32, 12); + xfer += oprot->writeI32((int32_t)this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -7087,32 +7223,41 @@ void swap(Partition &a, Partition &b) { swap(a.parameters, b.parameters); swap(a.privileges, b.privileges); swap(a.catName, b.catName); + swap(a.txnId, b.txnId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.isStatsCompliant, b.isStatsCompliant); swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other267) { - values = other267.values; - dbName = other267.dbName; - tableName = other267.tableName; - createTime = other267.createTime; - lastAccessTime = other267.lastAccessTime; - sd = other267.sd; - parameters = other267.parameters; - privileges = other267.privileges; - catName = other267.catName; - __isset = other267.__isset; -} -Partition& Partition::operator=(const Partition& other268) { - values = other268.values; - dbName = other268.dbName; - tableName = other268.tableName; - createTime = other268.createTime; - lastAccessTime = other268.lastAccessTime; - sd = other268.sd; - parameters = other268.parameters; - privileges = other268.privileges; - catName = other268.catName; - __isset = other268.__isset; +Partition::Partition(const Partition& other269) { + values = other269.values; + dbName = other269.dbName; + tableName = other269.tableName; + createTime = other269.createTime; + lastAccessTime = other269.lastAccessTime; + sd = other269.sd; + parameters = other269.parameters; + privileges = other269.privileges; + catName = other269.catName; + txnId = other269.txnId; + validWriteIdList = other269.validWriteIdList; + isStatsCompliant = other269.isStatsCompliant; + __isset = other269.__isset; +} +Partition& Partition::operator=(const Partition& other270) { + values = other270.values; + dbName = other270.dbName; + tableName = other270.tableName; + createTime = other270.createTime; + lastAccessTime = other270.lastAccessTime; + sd = other270.sd; + parameters = other270.parameters; + privileges = other270.privileges; + catName = other270.catName; + txnId = other270.txnId; + validWriteIdList = other270.validWriteIdList; + isStatsCompliant = other270.isStatsCompliant; + __isset = other270.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -7127,6 +7272,9 @@ void Partition::printTo(std::ostream& out) const { out << ", " << "parameters=" << to_string(parameters); out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "<null>")); out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "<null>")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "<null>")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "<null>")); out << ")"; } @@ -7185,14 +7333,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size269; - ::apache::thrift::protocol::TType _etype272; - xfer += iprot->readListBegin(_etype272, _size269); - this->values.resize(_size269); - uint32_t _i273; - for (_i273 = 0; _i273 < _size269; ++_i273) + uint32_t _size271; + ::apache::thrift::protocol::TType _etype274; + xfer += iprot->readListBegin(_etype274, _size271); + this->values.resize(_size271); + uint32_t _i275; + for (_i275 = 0; _i275 < _size271; ++_i275) { - xfer += iprot->readString(this->values[_i273]); + xfer += iprot->readString(this->values[_i275]); } xfer += iprot->readListEnd(); } @@ -7229,17 +7377,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size274; - ::apache::thrift::protocol::TType _ktype275; - ::apache::thrift::protocol::TType _vtype276; - xfer += iprot->readMapBegin(_ktype275, _vtype276, _size274); - uint32_t _i278; - for (_i278 = 0; _i278 < _size274; ++_i278) + uint32_t _size276; + ::apache::thrift::protocol::TType _ktype277; + ::apache::thrift::protocol::TType _vtype278; + xfer += iprot->readMapBegin(_ktype277, _vtype278, _size276); + uint32_t _i280; + for (_i280 = 0; _i280 < _size276; ++_i280) { - std::string _key279; - xfer += iprot->readString(_key279); - std::string& _val280 = this->parameters[_key279]; - xfer += iprot->readString(_val280); + std::string _key281; + xfer += iprot->readString(_key281); + std::string& _val282 = this->parameters[_key281]; + xfer += iprot->readString(_val282); } xfer += iprot->readMapEnd(); } @@ -7276,10 +7424,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 _iter281; - for (_iter281 = this->values.begin(); _iter281 != this->values.end(); ++_iter281) + std::vector<std::string> ::const_iterator _iter283; + for (_iter283 = this->values.begin(); _iter283 != this->values.end(); ++_iter283) { - xfer += oprot->writeString((*_iter281)); + xfer += oprot->writeString((*_iter283)); } xfer += oprot->writeListEnd(); } @@ -7300,11 +7448,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 _iter282; - for (_iter282 = this->parameters.begin(); _iter282 != this->parameters.end(); ++_iter282) + std::map<std::string, std::string> ::const_iterator _iter284; + for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284) { - xfer += oprot->writeString(_iter282->first); - xfer += oprot->writeString(_iter282->second); + xfer += oprot->writeString(_iter284->first); + xfer += oprot->writeString(_iter284->second); } xfer += oprot->writeMapEnd(); } @@ -7331,23 +7479,23 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other283) { - values = other283.values; - createTime = other283.createTime; - lastAccessTime = other283.lastAccessTime; - relativePath = other283.relativePath; - parameters = other283.parameters; - privileges = other283.privileges; - __isset = other283.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other284) { - values = other284.values; - createTime = other284.createTime; - lastAccessTime = other284.lastAccessTime; - relativePath = other284.relativePath; - parameters = other284.parameters; - privileges = other284.privileges; - __isset = other284.__isset; +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other285) { + values = other285.values; + createTime = other285.createTime; + lastAccessTime = other285.lastAccessTime; + relativePath = other285.relativePath; + parameters = other285.parameters; + privileges = other285.privileges; + __isset = other285.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other286) { + values = other286.values; + createTime = other286.createTime; + lastAccessTime = other286.lastAccessTime; + relativePath = other286.relativePath; + parameters = other286.parameters; + privileges = other286.privileges; + __isset = other286.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -7400,14 +7548,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size285; - ::apache::thrift::protocol::TType _etype288; - xfer += iprot->readListBegin(_etype288, _size285); - this->partitions.resize(_size285); - uint32_t _i289; - for (_i289 = 0; _i289 < _size285; ++_i289) + uint32_t _size287; + ::apache::thrift::protocol::TType _etype290; + xfer += iprot->readListBegin(_etype290, _size287); + this->partitions.resize(_size287); + uint32_t _i291; + for (_i291 = 0; _i291 < _size287; ++_i291) { - xfer += this->partitions[_i289].read(iprot); + xfer += this->partitions[_i291].read(iprot); } xfer += iprot->readListEnd(); } @@ -7444,10 +7592,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 _iter290; - for (_iter290 = this->partitions.begin(); _iter290 != this->partitions.end(); ++_iter290) + std::vector<PartitionWithoutSD> ::const_iterator _iter292; + for (_iter292 = this->partitions.begin(); _iter292 != this->partitions.end(); ++_iter292) { - xfer += (*_iter290).write(oprot); + xfer += (*_iter292).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7469,15 +7617,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other291) { - partitions = other291.partitions; - sd = other291.sd; - __isset = other291.__isset; +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other293) { + partitions = other293.partitions; + sd = other293.sd; + __isset = other293.__isset; } -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other292) { - partitions = other292.partitions; - sd = other292.sd; - __isset = other292.__isset; +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other294) { + partitions = other294.partitions; + sd = other294.sd; + __isset = other294.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -7522,14 +7670,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size293; - ::apache::thrift::protocol::TType _etype296; - xfer += iprot->readListBegin(_etype296, _size293); - this->partitions.resize(_size293); - uint32_t _i297; - for (_i297 = 0; _i297 < _size293; ++_i297) + uint32_t _size295; + ::apache::thrift::protocol::TType _etype298; + xfer += iprot->readListBegin(_etype298, _size295); + this->partitions.resize(_size295); + uint32_t _i299; + for (_i299 = 0; _i299 < _size295; ++_i299) { - xfer += this->partitions[_i297].read(iprot); + xfer += this->partitions[_i299].read(iprot); } xfer += iprot->readListEnd(); } @@ -7558,10 +7706,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 _iter298; - for (_iter298 = this->partitions.begin(); _iter298 != this->partitions.end(); ++_iter298) + std::vector<Partition> ::const_iterator _iter300; + for (_iter300 = this->partitions.begin(); _iter300 != this->partitions.end(); ++_iter300) { - xfer += (*_iter298).write(oprot); + xfer += (*_iter300).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7578,13 +7726,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other299) { - partitions = other299.partitions; - __isset = other299.__isset; +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other301) { + partitions = other301.partitions; + __isset = other301.__isset; } -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other300) { - partitions = other300.partitions; - __isset = other300.__isset; +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other302) { + partitions = other302.partitions; + __isset = other302.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -7626,6 +7774,21 @@ void PartitionSpec::__set_catName(const std::string& val) { __isset.catName = true; } +void PartitionSpec::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void PartitionSpec::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void PartitionSpec::__set_isStatsCompliant(const IsolationLevelCompliance::type val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + uint32_t PartitionSpec::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -7695,6 +7858,32 @@ uint32_t PartitionSpec::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast303; + xfer += iprot->readI32(ecast303); + this->isStatsCompliant = (IsolationLevelCompliance::type)ecast303; + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -7739,6 +7928,21 @@ uint32_t PartitionSpec::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeString(this->catName); xfer += oprot->writeFieldEnd(); } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_I32, 9); + xfer += oprot->writeI32((int32_t)this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -7752,26 +7956,35 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.sharedSDPartitionSpec, b.sharedSDPartitionSpec); swap(a.partitionList, b.partitionList); swap(a.catName, b.catName); + swap(a.txnId, b.txnId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.isStatsCompliant, b.isStatsCompliant); swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other301) { - dbName = other301.dbName; - tableName = other301.tableName; - rootPath = other301.rootPath; - sharedSDPartitionSpec = other301.sharedSDPartitionSpec; - partitionList = other301.partitionList; - catName = other301.catName; - __isset = other301.__isset; +PartitionSpec::PartitionSpec(const PartitionSpec& other304) { + dbName = other304.dbName; + tableName = other304.tableName; + rootPath = other304.rootPath; + sharedSDPartitionSpec = other304.sharedSDPartitionSpec; + partitionList = other304.partitionList; + catName = other304.catName; + txnId = other304.txnId; + validWriteIdList = other304.validWriteIdList; + isStatsCompliant = other304.isStatsCompliant; + __isset = other304.__isset; } -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other302) { - dbName = other302.dbName; - tableName = other302.tableName; - rootPath = other302.rootPath; - sharedSDPartitionSpec = other302.sharedSDPartitionSpec; - partitionList = other302.partitionList; - catName = other302.catName; - __isset = other302.__isset; +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other305) { + dbName = other305.dbName; + tableName = other305.tableName; + rootPath = other305.rootPath; + sharedSDPartitionSpec = other305.sharedSDPartitionSpec; + partitionList = other305.partitionList; + catName = other305.catName; + txnId = other305.txnId; + validWriteIdList = other305.validWriteIdList; + isStatsCompliant = other305.isStatsCompliant; + __isset = other305.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -7783,6 +7996,9 @@ void PartitionSpec::printTo(std::ostream& out) const { out << ", " << "sharedSDPartitionSpec="; (__isset.sharedSDPartitionSpec ? (out << to_string(sharedSDPartitionSpec)) : (out << "<null>")); out << ", " << "partitionList="; (__isset.partitionList ? (out << to_string(partitionList)) : (out << "<null>")); out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "<null>")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "<null>")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "<null>")); out << ")"; } @@ -7918,19 +8134,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other303) { - numTrues = other303.numTrues; - numFalses = other303.numFalses; - numNulls = other303.numNulls; - bitVectors = other303.bitVectors; - __isset = other303.__isset; +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other306) { + numTrues = other306.numTrues; + numFalses = other306.numFalses; + numNulls = other306.numNulls; + bitVectors = other306.bitVectors; + __isset = other306.__isset; } -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other304) { - numTrues = other304.numTrues; - numFalses = other304.numFalses; - numNulls = other304.numNulls; - bitVectors = other304.bitVectors; - __isset = other304.__isset; +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other307) { + numTrues = other307.numTrues; + numFalses = other307.numFalses; + numNulls = other307.numNulls; + bitVectors = other307.bitVectors; + __isset = other307.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -8093,21 +8309,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other305) { - lowValue = other305.lowValue; - highValue = other305.highValue; - numNulls = other305.numNulls; - numDVs = other305.numDVs; - bitVectors = other305.bitVectors; - __isset = other305.__isset; +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other308) { + lowValue = other308.lowValue; + highValue = other308.highValue; + numNulls = other308.numNulls; + numDVs = other308.numDVs; + bitVectors = other308.bitVectors; + __isset = other308.__isset; } -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other306) { - lowValue = other306.lowValue; - highValue = other306.highValue; - numNulls = other306.numNulls; - numDVs = other306.numDVs; - bitVectors = other306.bitVectors; - __isset = other306.__isset; +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other309) { + lowValue = other309.lowValue; + highValue = other309.highValue; + numNulls = other309.numNulls; + numDVs = other309.numDVs; + bitVectors = other309.bitVectors; + __isset = other309.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -8271,21 +8487,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other307) { - lowValue = other307.lowValue; - highValue = other307.highValue; - numNulls = other307.numNulls; - numDVs = other307.numDVs; - bitVectors = other307.bitVectors; - __isset = other307.__isset; +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other310) { + lowValue = other310.lowValue; + highValue = other310.highValue; + numNulls = other310.numNulls; + numDVs = other310.numDVs; + bitVectors = other310.bitVectors; + __isset = other310.__isset; } -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other308) { - lowValue = other308.lowValue; - highValue = other308.highValue; - numNulls = other308.numNulls; - numDVs = other308.numDVs; - bitVectors = other308.bitVectors; - __isset = other308.__isset; +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other311) { + lowValue = other311.lowValue; + highValue = other311.highValue; + numNulls = other311.numNulls; + numDVs = other311.numDVs; + bitVectors = other311.bitVectors; + __isset = other311.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -8451,21 +8667,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other309) { - maxColLen = other309.maxColLen; - avgColLen = other309.avgColLen; - numNulls = other309.numNulls; - numDVs = other309.numDVs; - bitVectors = other309.bitVectors; - __isset = other309.__isset; +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other312) { + maxColLen = other312.maxColLen; + avgColLen = other312.avgColLen; + numNulls = other312.numNulls; + numDVs = other312.numDVs; + bitVectors = other312.bitVectors; + __isset = other312.__isset; } -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other310) { - maxColLen = other310.maxColLen; - avgColLen = other310.avgColLen; - numNulls = other310.numNulls; - numDVs = other310.numDVs; - bitVectors = other310.bitVectors; - __isset = other310.__isset; +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other313) { + maxColLen = other313.maxColLen; + avgColLen = other313.avgColLen; + numNulls = other313.numNulls; + numDVs = other313.numDVs; + bitVectors = other313.bitVectors; + __isset = other313.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -8611,19 +8827,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other311) { - maxColLen = other311.maxColLen; - avgColLen = other311.avgColLen; - numNulls = other311.numNulls; - bitVectors = other311.bitVectors; - __isset = other311.__isset; +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other314) { + maxColLen = other314.maxColLen; + avgColLen = other314.avgColLen; + numNulls = other314.numNulls; + bitVectors = other314.bitVectors; + __isset = other314.__isset; } -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other312) { - maxColLen = other312.maxColLen; - avgColLen = other312.avgColLen; - numNulls = other312.numNulls; - bitVectors = other312.bitVectors; - __isset = other312.__isset; +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other315) { + maxColLen = other315.maxColLen; + avgColLen = other315.avgColLen; + numNulls = other315.numNulls; + bitVectors = other315.bitVectors; + __isset = other315.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -8728,13 +8944,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.unscaled, b.unscaled); } -Decimal::Decimal(const Decimal& other313) { - scale = other313.scale; - unscaled = other313.unscaled; +Decimal::Decimal(const Decimal& other316) { + scale = other316.scale; + unscaled = other316.unscaled; } -Decimal& Decimal::operator=(const Decimal& other314) { - scale = other314.scale; - unscaled = other314.unscaled; +Decimal& Decimal::operator=(const Decimal& other317) { + scale = other317.scale; + unscaled = other317.unscaled; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -8895,21 +9111,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other315) { - lowValue = other315.lowValue; - highValue = other315.highValue; - numNulls = other315.numNulls; - numDVs = other315.numDVs; - bitVectors = other315.bitVectors; - __isset = other315.__isset; +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other318) { + lowValue = other318.lowValue; + highValue = other318.highValue; + numNulls = other318.numNulls; + numDVs = other318.numDVs; + bitVectors = other318.bitVectors; + __isset = other318.__isset; } -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other316) { - lowValue = other316.lowValue; - highValue = other316.highValue; - numNulls = other316.numNulls; - numDVs = other316.numDVs; - bitVectors = other316.bitVectors; - __isset = other316.__isset; +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other319) { + lowValue = other319.lowValue; + highValue = other319.highValue; + numNulls = other319.numNulls; + numDVs = other319.numDVs; + bitVectors = other319.bitVectors; + __isset = other319.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -8995,11 +9211,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other317) { - daysSinceEpoch = other317.daysSinceEpoch; +Date::Date(const Date& other320) { + daysSinceEpoch = other320.daysSinceEpoch; } -Date& Date::operator=(const Date& other318) { - daysSinceEpoch = other318.daysSinceEpoch; +Date& Date::operator=(const Date& other321) { + daysSinceEpoch = other321.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -9159,21 +9375,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other319) { - lowValue = other319.lowValue; - highValue = other319.highValue; - numNulls = other319.numNulls; - numDVs = other319.numDVs; - bitVectors = other319.bitVectors; - __isset = other319.__isset; +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other322) { + lowValue = other322.lowValue; + highValue = other322.highValue; + numNulls = other322.numNulls; + numDVs = other322.numDVs; + bitVectors = other322.bitVectors; + __isset = other322.__isset; } -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other320) { - lowValue = other320.lowValue; - highValue = other320.highValue; - numNulls = other320.numNulls; - numDVs = other320.numDVs; - bitVectors = other320.bitVectors; - __isset = other320.__isset; +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other323) { + lowValue = other323.lowValue; + highValue = other323.highValue; + numNulls = other323.numNulls; + numDVs = other323.numDVs; + bitVectors = other323.bitVectors; + __isset = other323.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -9359,25 +9575,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other321) { - booleanStats = other321.booleanStats; - longStats = other321.longStats; - doubleStats = other321.doubleStats; - stringStats = other321.stringStats; - binaryStats = other321.binaryStats; - decimalStats = other321.decimalStats; - dateStats = other321.dateStats; - __isset = other321.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other322) { - booleanStats = other322.booleanStats; - longStats = other322.longStats; - doubleStats = other322.doubleStats; - stringStats = other322.stringStats; - binaryStats = other322.binaryStats; - decimalStats = other322.decimalStats; - dateStats = other322.dateStats; - __isset = other322.__isset; +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other324) { + booleanStats = other324.booleanStats; + longStats = other324.longStats; + doubleStats = other324.doubleStats; + stringStats = other324.stringStats; + binaryStats = other324.binaryStats; + decimalStats = other324.decimalStats; + dateStats = other324.dateStats; + __isset = other324.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other325) { + booleanStats = other325.booleanStats; + longStats = other325.longStats; + doubleStats = other325.doubleStats; + stringStats = other325.stringStats; + binaryStats = other325.binaryStats; + decimalStats = other325.decimalStats; + dateStats = other325.dateStats; + __isset = other325.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -9505,15 +9721,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other323) { - colName = other323.colName; - colType = other323.colType; - statsData = other323.statsData; +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other326) { + colName = other326.colName; + colType = other326.colType; + statsData = other326.statsData; } -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other324) { - colName = other324.colName; - colType = other324.colType; - statsData = other324.statsData; +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other327) { + colName = other327.colName; + colType = other327.colType; + statsData = other327.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -9695,23 +9911,23 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other325) { - isTblLevel = other325.isTblLevel; - dbName = other325.dbName; - tableName = other325.tableName; - partName = other325.partName; - lastAnalyzed = other325.lastAnalyzed; - catName = other325.catName; - __isset = other325.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other326) { - isTblLevel = other326.isTblLevel; - dbName = other326.dbName; - tableName = other326.tableName; - partName = other326.partName; - lastAnalyzed = other326.lastAnalyzed; - catName = other326.catName; - __isset = other326.__isset; +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other328) { + isTblLevel = other328.isTblLevel; + dbName = other328.dbName; + tableName = other328.tableName; + partName = other328.partName; + lastAnalyzed = other328.lastAnalyzed; + catName = other328.catName; + __isset = other328.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other329) { + isTblLevel = other329.isTblLevel; + dbName = other329.dbName; + tableName = other329.tableName; + partName = other329.partName; + lastAnalyzed = other329.lastAnalyzed; + catName = other329.catName; + __isset = other329.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -9739,6 +9955,21 @@ void ColumnStatistics::__set_statsObj(const std::vector<ColumnStatisticsObj> & v this->statsObj = val; } +void ColumnStatistics::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void ColumnStatistics::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void ColumnStatistics::__set_isStatsCompliant(const IsolationLevelCompliance::type val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -9774,14 +10005,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size327; - ::apache::thrift::protocol::TType _etype330; - xfer += iprot->readListBegin(_etype330, _size327); - this->statsObj.resize(_size327); - uint32_t _i331; - for (_i331 = 0; _i331 < _size327; ++_i331) + uint32_t _size330; + ::apache::thrift::protocol::TType _etype333; + xfer += iprot->readListBegin(_etype333, _size330); + this->statsObj.resize(_size330); + uint32_t _i334; + for (_i334 = 0; _i334 < _size330; ++_i334) { - xfer += this->statsObj[_i331].read(iprot); + xfer += this->statsObj[_i334].read(iprot); } xfer += iprot->readListEnd(); } @@ -9790,6 +10021,32 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast335; + xfer += iprot->readI32(ecast335); + this->isStatsCompliant = (IsolationLevelCompliance::type)ecast335; + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -9818,15 +10075,30 @@ 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 _iter332; - for (_iter332 = this->statsObj.begin(); _iter332 != this->statsObj.end(); ++_iter332) + std::vector<ColumnStatisticsObj> ::const_iterator _iter336; + for (_iter336 = this->statsObj.begin(); _iter336 != this->statsObj.end(); ++_iter336) { - xfer += (*_iter332).write(oprot); + xfer += (*_iter336).write(oprot); } xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32((int32_t)this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -9836,15 +10108,27 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { using ::std::swap; swap(a.statsDesc, b.statsDesc); swap(a.statsObj, b.statsObj); + swap(a.txnId, b.txnId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other333) { - statsDesc = other333.statsDesc; - statsObj = other333.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other334) { - statsDesc = other334.statsDesc; - statsObj = other334.statsObj; +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other337) { + statsDesc = other337.statsDesc; + statsObj = other337.statsObj; + txnId = other337.txnId; + validWriteIdList = other337.validWriteIdList; + isStatsCompliant = other337.isStatsCompliant; + __isset = other337.__isset; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other338) { + statsDesc = other338.statsDesc; + statsObj = other338.statsObj; + txnId = other338.txnId; + validWriteIdList = other338.validWriteIdList; + isStatsCompliant = other338.isStatsCompliant; + __isset = other338.__isset; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -9852,6 +10136,9 @@ void ColumnStatistics::printTo(std::ostream& out) const { out << "ColumnStatistics("; out << "statsDesc=" << to_string(statsDesc); out << ", " << "statsObj=" << to_string(statsObj); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "<null>")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "<null>")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "<null>")); out << ")"; } @@ -9868,6 +10155,11 @@ void AggrStats::__set_partsFound(const int64_t val) { this->partsFound = val; } +void AggrStats::__set_isStatsCompliant(const IsolationLevelCompliance::type val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -9895,14 +10187,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { 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 _size339; + ::apache::thrift::protocol::TType _etype342; + xfer += iprot->readListBegin(_etype342, _size339); + this->colStats.resize(_size339); + uint32_t _i343; + for (_i343 = 0; _i343 < _size339; ++_i343) { - xfer += this->colStats[_i339].read(iprot); + xfer += this->colStats[_i343].read(iprot); } xfer += iprot->readListEnd(); } @@ -9919,6 +10211,16 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast344; + xfer += iprot->readI32(ecast344); + this->isStatsCompliant = (IsolationLevelCompliance::type)ecast344; + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -9943,10 +10245,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 _iter340; - for (_iter340 = this->colStats.begin(); _iter340 != this->colStats.end(); ++_iter340) + std::vector<ColumnStatisticsObj> ::const_iterator _iter345; + for (_iter345 = this->colStats.begin(); _iter345 != this->colStats.end(); ++_iter345) { - xfer += (*_iter340).write(oprot); + xfer += (*_iter345).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9956,6 +10258,11 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeI64(this->partsFound); xfer += oprot->writeFieldEnd(); + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -9965,15 +10272,21 @@ void swap(AggrStats &a, AggrStats &b) { using ::std::swap; swap(a.colStats, b.colStats); swap(a.partsFound, b.partsFound); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); } -AggrStats::AggrStats(const AggrStats& other341) { - colStats = other341.colStats; - partsFound = other341.partsFound; +AggrStats::AggrStats(const AggrStats& other346) { + colStats = other346.colStats; + partsFound = other346.partsFound; + isStatsCompliant = other346.isStatsCompliant; + __isset = other346.__isset; } -AggrStats& AggrStats::operator=(const AggrStats& other342) { - colStats = other342.colStats; - partsFound = other342.partsFound; +AggrStats& AggrStats::operator=(const AggrStats& other347) { + colStats = other347.colStats; + partsFound = other347.partsFound; + isStatsCompliant = other347.isStatsCompliant; + __isset = other347.__isset; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -9981,6 +10294,7 @@ void AggrStats::printTo(std::ostream& out) const { out << "AggrStats("; out << "colStats=" << to_string(colStats); out << ", " << "partsFound=" << to_string(partsFound); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "<null>")); out << ")"; } @@ -9998,6 +10312,16 @@ void SetPartitionsStatsRequest::__set_needMerge(const bool val) { __isset.needMerge = true; } +void SetPartitionsStatsRequest::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void SetPartitionsStatsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -10024,14 +10348,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size343; - ::apache::thrift::protocol::TType _etype346; - xfer += iprot->readListBegin(_etype346, _size343); - this->colStats.resize(_size343); - uint32_t _i347; - for (_i347 = 0; _i347 < _size343; ++_i347) + uint32_t _size348; + ::apache::thrift::protocol::TType _etype351; + xfer += iprot->readListBegin(_etype351, _size348); + this->colStats.resize(_size348); + uint32_t _i352; + for (_i352 = 0; _i352 < _size348; ++_i352) { - xfer += this->colStats[_i347].read(iprot); + xfer += this->colStats[_i352].read(iprot); } xfer += iprot->readListEnd(); } @@ -10048,6 +10372,22 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* xfer += iprot->skip(ftype); } break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -10070,10 +10410,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 _iter348; - for (_iter348 = this->colStats.begin(); _iter348 != this->colStats.end(); ++_iter348) + std::vector<ColumnStatistics> ::const_iterator _iter353; + for (_iter353 = this->colStats.begin(); _iter353 != this->colStats.end(); ++_iter353) { - xfer += (*_iter348).write(oprot); + xfer += (*_iter353).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10084,6 +10424,16 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeBool(this->needMerge); xfer += oprot->writeFieldEnd(); } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -10093,18 +10443,24 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { using ::std::swap; swap(a.colStats, b.colStats); swap(a.needMerge, b.needMerge); + swap(a.txnId, b.txnId); + swap(a.validWriteIdList, b.validWriteIdList); swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other349) { - colStats = other349.colStats; - needMerge = other349.needMerge; - __isset = other349.__isset; +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other354) { + colStats = other354.colStats; + needMerge = other354.needMerge; + txnId = other354.txnId; + validWriteIdList = other354.validWriteIdList; + __isset = other354.__isset; } -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other350) { - colStats = other350.colStats; - needMerge = other350.needMerge; - __isset = other350.__isset; +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other355) { + colStats = other355.colStats; + needMerge = other355.needMerge; + txnId = other355.txnId; + validWriteIdList = other355.validWriteIdList; + __isset = other355.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -10112,6 +10468,8 @@ void SetPartitionsStatsRequest::printTo(std::ostream& out) const { out << "SetPartitionsStatsRequest("; out << "colStats=" << to_string(colStats); out << ", " << "needMerge="; (__isset.needMerge ? (out << to_string(needMerge)) : (out << "<null>")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "<null>")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "<null>")); out << ")"; } @@ -10153,14 +10511,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size351; - ::apache::thrift::protocol::TType _etype354; - xfer += iprot->readListBegin(_etype354, _size351); - this->fieldSchemas.resize(_size351); - uint32_t _i355; - for (_i355 = 0; _i355 < _size351; ++_i355) + uint32_t _size356; + ::apache::thrift::protocol::TType _etype359; + xfer += iprot->readListBegin(_etype359, _size356); + this->fieldSchemas.resize(_size356); + uint32_t _i360; + for (_i360 = 0; _i360 < _size356; ++_i360) { - xfer += this->fieldSchemas[_i355].read(iprot); + xfer += this->fieldSchemas[_i360].read(iprot); } xfer += iprot->readListEnd(); } @@ -10173,17 +10531,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size356; - ::apache::thrift::protocol::TType _ktype357; - ::apache::thrift::protocol::TType _vtype358; - xfer += iprot->readMapBegin(_ktype357, _vtype358, _size356); - uint32_t _i360; - for (_i360 = 0; _i360 < _size356; ++_i360) + uint32_t _size361; + ::apache::thrift::protocol::TType _ktype362; + ::apache::thrift::protocol::TType _vtype363; + xfer += iprot->readMapBegin(_ktype362, _vtype363, _size361); + uint32_t _i365; + for (_i365 = 0; _i365 < _size361; ++_i365) { - std::string _key361; - xfer += iprot->readString(_key361); - std::string& _val362 = this->properties[_key361]; - xfer += iprot->readString(_val362); + std::string _key366; + xfer += iprot->readString(_key366); + std::string& _val367 = this->properties[_key366]; + xfer += iprot->readString(_val367); } xfer += iprot->readMapEnd(); } @@ -10212,10 +10570,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 _iter363; - for (_iter363 = this->fieldSchemas.begin(); _iter363 != this->fieldSchemas.end(); ++_iter363) + std::vector<FieldSchema> ::const_iterator _iter368; + for (_iter368 = this->fieldSchemas.begin(); _iter368 != this->fieldSchemas.end(); ++_iter368) { - xfer += (*_iter363).write(oprot); + xfer += (*_iter368).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10224,11 +10582,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 _iter364; - for (_iter364 = this->properties.begin(); _iter364 != this->properties.end(); ++_iter364) + std::map<std::string, std::string> ::const_iterator _iter369; + for (_iter369 = this->properties.begin(); _iter369 != this->properties.end(); ++_iter369) { - xfer += oprot->writeString(_iter364->first); - xfer += oprot->writeString(_iter364->second); + xfer += oprot->writeString(_iter369->first); + xfer += oprot->writeString(_iter369->second); } xfer += oprot->writeMapEnd(); } @@ -10246,15 +10604,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other365) { - fieldSchemas = other365.fieldSchemas; - properties = other365.properties; - __isset = other365.__isset; +Schema::Schema(const Schema& other370) { + fieldSchemas = other370.fieldSchemas; + properties = other370.properties; + __isset = other370.__isset; } -Schema& Schema::operator=(const Schema& other366) { - fieldSchemas = other366.fieldSchemas; - properties = other366.properties; - __isset = other366.__isset; +Schema& Schema::operator=(const Schema& other371) { + fieldSchemas = other371.fieldSchemas; + properties = other371.properties; + __isset = other371.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -10299,17 +10657,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size367; - ::apache::thrift::protocol::TType _ktype368; - ::apache::thrift::protocol::TType _vtype369; - xfer += iprot->readMapBegin(_ktype368, _vtype369, _size367); - uint32_t _i371; - for (_i371 = 0; _i371 < _size367; ++_i371) + uint32_t _size372; + ::apache::thrift::protocol::TType _ktype373; + ::apache::thrift::protocol::TType _vtype374; + xfer += iprot->readMapBegin(_ktype373, _vtype374, _size372); + uint32_t _i376; + for (_i376 = 0; _i376 < _size372; ++_i376) { - std::string _key372; - xfer += iprot->readString(_key372); - std::string& _val373 = this->properties[_key372]; - xfer += iprot->readString(_val373); + std::string _key377; + xfer += iprot->readString(_key377); + std::string& _val378 = this->properties[_key377]; + xfer += iprot->readString(_val378); } xfer += iprot->readMapEnd(); } @@ -10338,11 +10696,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 _iter374; - for (_iter374 = this->properties.begin(); _iter374 != this->properties.end(); ++_iter374) + std::map<std::string, std::string> ::const_iterator _iter379; + for (_iter379 = this->properties.begin(); _iter379 != this->properties.end(); ++_iter379) { - xfer += oprot->writeString(_iter374->first); - xfer += oprot->writeString(_iter374->second); + xfer += oprot->writeString(_iter379->first); + xfer += oprot->writeString(_iter379->second); } xfer += oprot->writeMapEnd(); } @@ -10359,13 +10717,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other375) { - properties = other375.properties; - __isset = other375.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other380) { + properties = other380.properties; + __isset = other380.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other376) { - properties = other376.properties; - __isset = other376.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other381) { + properties = other381.properties; + __isset = other381.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -10487,17 +10845,17 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.__isset, b.__isset); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other377) { - db_name = other377.db_name; - tbl_name = other377.tbl_name; - catName = other377.catName; - __isset = other377.__isset; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other382) { + db_name = other382.db_name; + tbl_name = other382.tbl_name; + catName = other382.catName; + __isset = other382.__isset; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other378) { - db_name = other378.db_name; - tbl_name = other378.tbl_name; - catName = other378.catName; - __isset = other378.__isset; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other383) { + db_name = other383.db_name; + tbl_name = other383.tbl_name; + catName = other383.catName; + __isset = other383.__isset; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -10544,14 +10902,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size379; - ::apache::thrift::protocol::TType _etype382; - xfer += iprot->readListBegin(_etype382, _size379); - this->primaryKeys.resize(_size379); - uint32_t _i383; - for (_i383 = 0; _i383 < _size379; ++_i383) + uint32_t _size384; + ::apache::thrift::protocol::TType _etype387; + xfer += iprot->readListBegin(_etype387, _size384); + this->primaryKeys.resize(_size384); + uint32_t _i388; + for (_i388 = 0; _i388 < _size384; ++_i388) { - xfer += this->primaryKeys[_i383].read(iprot); + xfer += this->primaryKeys[_i388].read(iprot); } xfer += iprot->readListEnd(); } @@ -10582,10 +10940,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 _iter384; - for (_iter384 = this->primaryKeys.begin(); _iter384 != this->primaryKeys.end(); ++_iter384) + std::vector<SQLPrimaryKey> ::const_iterator _iter389; + for (_iter389 = this->primaryKeys.begin(); _iter389 != this->primaryKeys.end(); ++_iter389) { - xfer += (*_iter384).write(oprot); + xfer += (*_iter389).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10601,11 +10959,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other385) { - primaryKeys = other385.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other390) { + primaryKeys = other390.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other386) { - primaryKeys = other386.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other391) { + primaryKeys = other391.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -10755,21 +11113,21 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other387) { - parent_db_name = other387.parent_db_name; - parent_tbl_name = other387.parent_tbl_name; - foreign_db_name = other387.foreign_db_name; - foreign_tbl_name = other387.foreign_tbl_name; - catName = other387.catName; - __isset = other387.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other388) { - parent_db_name = other388.parent_db_name; - parent_tbl_name = other388.parent_tbl_name; - foreign_db_name = other388.foreign_db_name; - foreign_tbl_name = other388.foreign_tbl_name; - catName = other388.catName; - __isset = other388.__isset; +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other392) { + parent_db_name = other392.parent_db_name; + parent_tbl_name = other392.parent_tbl_name; + foreign_db_name = other392.foreign_db_name; + foreign_tbl_name = other392.foreign_tbl_name; + catName = other392.catName; + __isset = other392.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other393) { + parent_db_name = other393.parent_db_name; + parent_tbl_name = other393.parent_tbl_name; + foreign_db_name = other393.foreign_db_name; + foreign_tbl_name = other393.foreign_tbl_name; + catName = other393.catName; + __isset = other393.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -10818,14 +11176,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size389; - ::apache::thrift::protocol::TType _etype392; - xfer += iprot->readListBegin(_etype392, _size389); - this->foreignKeys.resize(_size389); - uint32_t _i393; - for (_i393 = 0; _i393 < _size389; ++_i393) + uint32_t _size394; + ::apache::thrift::protocol::TType _etype397; + xfer += iprot->readListBegin(_etype397, _size394); + this->foreignKeys.resize(_size394); + uint32_t _i398; + for (_i398 = 0; _i398 < _size394; ++_i398) { - xfer += this->foreignKeys[_i393].read(iprot); + xfer += this->foreignKeys[_i398].read(iprot); } xfer += iprot->readListEnd(); } @@ -10856,10 +11214,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 _iter394; - for (_iter394 = this->foreignKeys.begin(); _iter394 != this->foreignKeys.end(); ++_iter394) + std::vector<SQLForeignKey> ::const_iterator _iter399; + for (_iter399 = this->foreignKeys.begin(); _iter399 != this->foreignKeys.end(); ++_iter399) { - xfer += (*_iter394).write(oprot); + xfer += (*_iter399).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10875,11 +11233,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other395) { - foreignKeys = other395.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other400) { + foreignKeys = other400.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other396) { - foreignKeys = other396.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other401) { + foreignKeys = other401.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -11001,15 +11359,15 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other397) { - catName = other397.catName; - db_name = other397.db_name; - tbl_name = other397.tbl_name; +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other402) { + catName = other402.catName; + db_name = other402.db_name; + tbl_name = other402.tbl_name; } -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other398) { - catName = other398.catName; - db_name = other398.db_name; - tbl_name = other398.tbl_name; +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other403) { + catName = other403.catName; + db_name = other403.db_name; + tbl_name = other403.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -11056,14 +11414,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size399; - ::apache::thrift::protocol::TType _etype402; - xfer += iprot->readListBegin(_etype402, _size399); - this->uniqueConstraints.resize(_size399); - uint32_t _i403; - for (_i403 = 0; _i403 < _size399; ++_i403) + uint32_t _size404; + ::apache::thrift::protocol::TType _etype407; + xfer += iprot->readListBegin(_etype407, _size404); + this->uniqueConstraints.resize(_size404); + uint32_t _i408; + for (_i408 = 0; _i408 < _size404; ++_i408) { - xfer += this->uniqueConstraints[_i403].read(iprot); + xfer += this->uniqueConstraints[_i408].read(iprot); } xfer += iprot->readListEnd(); } @@ -11094,10 +11452,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 _iter404; - for (_iter404 = this->uniqueConstraints.begin(); _iter404 != this->uniqueConstraints.end(); ++_iter404) + std::vector<SQLUniqueConstraint> ::const_iterator _iter409; + for (_iter409 = this->uniqueConstraints.begin(); _iter409 != this->uniqueConstraints.end(); ++_iter409) { - xfer += (*_iter404).write(oprot); + xfer += (*_iter409).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11113,11 +11471,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other405) { - uniqueConstraints = other405.uniqueConstraints; +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other410) { + uniqueConstraints = other410.uniqueConstraints; } -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other406) { - uniqueConstraints = other406.uniqueConstraints; +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other411) { + uniqueConstraints = other411.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -11239,15 +11597,15 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other407) { - catName = other407.catName; - db_name = other407.db_name; - tbl_name = other407.tbl_name; +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other412) { + catName = other412.catName; + db_name = other412.db_name; + tbl_name = other412.tbl_name; } -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other408) { - catName = other408.catName; - db_name = other408.db_name; - tbl_name = other408.tbl_name; +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other413) { + catName = other413.catName; + db_name = other413.db_name; + tbl_name = other413.tbl_name; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -11294,14 +11652,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size409; - ::apache::thrift::protocol::TType _etype412; - xfer += iprot->readListBegin(_etype412, _size409); - this->notNullConstraints.resize(_size409); - uint32_t _i413; - for (_i413 = 0; _i413 < _size409; ++_i413) + uint32_t _size414; + ::apache::thrift::protocol::TType _etype417; + xfer += iprot->readListBegin(_etype417, _size414); + this->notNullConstraints.resize(_size414); + uint32_t _i418; + for (_i418 = 0; _i418 < _size414; ++_i418) { - xfer += this->notNullConstraints[_i413].read(iprot); + xfer += this->notNullConstraints[_i418].read(iprot); } xfer += iprot->readListEnd(); } @@ -11332,10 +11690,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 _iter414; - for (_iter414 = this->notNullConstraints.begin(); _iter414 != this->notNullConstraints.end(); ++_iter414) + std::vector<SQLNotNullConstraint> ::const_iterator _iter419; + for (_iter419 = this->notNullConstraints.begin(); _iter419 != this->notNullConstraints.end(); ++_iter419) { - xfer += (*_iter414).write(oprot); + xfer += (*_iter419).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11351,11 +11709,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other415) { - notNullConstraints = other415.notNullConstraints; +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other420) { + notNullConstraints = other420.notNullConstraints; } -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other416) { - notNullConstraints = other416.notNullConstraints; +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other421) { + notNullConstraints = other421.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::
<TRUNCATED>