diff --git hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/HiveEndPoint.java hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/HiveEndPoint.java index db9fd72..cb64fff 100644 --- hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/HiveEndPoint.java +++ hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/HiveEndPoint.java @@ -19,6 +19,7 @@ package org.apache.hive.hcatalog.streaming; import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hive.cli.CliSessionState; @@ -964,7 +965,8 @@ private static LockRequest createLockRequest(final HiveEndPoint hiveEndPoint, LockComponentBuilder lockCompBuilder = new LockComponentBuilder() .setDbName(hiveEndPoint.database) .setTableName(hiveEndPoint.table) - .setShared(); + .setShared() + .setOperationType(DataOperationType.INSERT); if (partNameForLock!=null && !partNameForLock.isEmpty() ) { lockCompBuilder.setPartitionName(partNameForLock); } diff --git hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/mutate/client/lock/Lock.java hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/mutate/client/lock/Lock.java index 17fa91a..6e30abc 100644 --- hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/mutate/client/lock/Lock.java +++ hcatalog/streaming/src/java/org/apache/hive/hcatalog/streaming/mutate/client/lock/Lock.java @@ -31,6 +31,7 @@ import org.apache.hadoop.hive.metastore.IMetaStoreClient; import org.apache.hadoop.hive.metastore.LockComponentBuilder; import org.apache.hadoop.hive.metastore.LockRequestBuilder; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockRequest; import org.apache.hadoop.hive.metastore.api.LockResponse; @@ -178,10 +179,12 @@ private LockRequest buildLockRequest(Long transactionId) { for (Table table : tables) { LockComponentBuilder componentBuilder = new LockComponentBuilder().setDbName(table.getDbName()).setTableName( table.getTableName()); + //todo: DataOperationType is set conservatively here, we'd really want to distinguish update/delete + //and insert/select if (sinks.contains(table)) { - componentBuilder.setSemiShared(); + componentBuilder.setSemiShared().setOperationType(DataOperationType.UPDATE).setIsAcid(true); } else { - componentBuilder.setShared(); + componentBuilder.setShared().setOperationType(DataOperationType.SELECT); } LockComponent component = componentBuilder.build(); requestBuilder.addLockComponent(component); diff --git hcatalog/streaming/src/test/org/apache/hive/hcatalog/streaming/mutate/client/lock/TestLock.java hcatalog/streaming/src/test/org/apache/hive/hcatalog/streaming/mutate/client/lock/TestLock.java index cf56176..b8c5971 100644 --- hcatalog/streaming/src/test/org/apache/hive/hcatalog/streaming/mutate/client/lock/TestLock.java +++ hcatalog/streaming/src/test/org/apache/hive/hcatalog/streaming/mutate/client/lock/TestLock.java @@ -43,6 +43,7 @@ import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockLevel; import org.apache.hadoop.hive.metastore.api.LockRequest; @@ -174,10 +175,12 @@ public void testAcquireReadLockCheckLocks() throws Exception { LockComponent expected1 = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "DB"); expected1.setTablename("SOURCE_1"); + expected1.setOperationType(DataOperationType.SELECT); assertTrue(components.contains(expected1)); LockComponent expected2 = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "DB"); expected2.setTablename("SOURCE_2"); + expected2.setOperationType(DataOperationType.SELECT); assertTrue(components.contains(expected2)); } @@ -197,14 +200,18 @@ public void testAcquireTxnLockCheckLocks() throws Exception { LockComponent expected1 = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "DB"); expected1.setTablename("SOURCE_1"); + expected1.setOperationType(DataOperationType.SELECT); assertTrue(components.contains(expected1)); LockComponent expected2 = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "DB"); expected2.setTablename("SOURCE_2"); + expected2.setOperationType(DataOperationType.SELECT); assertTrue(components.contains(expected2)); LockComponent expected3 = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "DB"); expected3.setTablename("SINK"); + expected3.setOperationType(DataOperationType.UPDATE); + expected3.setIsAcid(true); assertTrue(components.contains(expected3)); } diff --git itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreTxns.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreTxns.java index 22354ab..997f73e 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreTxns.java +++ itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreTxns.java @@ -22,6 +22,7 @@ import org.apache.hadoop.hive.common.ValidTxnList; import org.apache.hadoop.hive.common.ValidReadTxnList; import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.HeartbeatTxnRangeResponse; import org.apache.hadoop.hive.metastore.api.LockResponse; import org.apache.hadoop.hive.metastore.api.LockState; @@ -152,14 +153,17 @@ public void testLocks() throws Exception { .setTableName("mytable") .setPartitionName("mypartition") .setExclusive() + .setOperationType(DataOperationType.NO_TXN) .build()); rqstBuilder.addLockComponent(new LockComponentBuilder() .setDbName("mydb") .setTableName("yourtable") .setSemiShared() + .setOperationType(DataOperationType.NO_TXN) .build()); rqstBuilder.addLockComponent(new LockComponentBuilder() .setDbName("yourdb") + .setOperationType(DataOperationType.NO_TXN) .setShared() .build()); rqstBuilder.setUser("fred"); @@ -188,15 +192,18 @@ public void testLocksWithTxn() throws Exception { .setTableName("mytable") .setPartitionName("mypartition") .setSemiShared() + .setOperationType(DataOperationType.UPDATE) .build()) .addLockComponent(new LockComponentBuilder() .setDbName("mydb") .setTableName("yourtable") .setSemiShared() + .setOperationType(DataOperationType.UPDATE) .build()) .addLockComponent(new LockComponentBuilder() .setDbName("yourdb") .setShared() + .setOperationType(DataOperationType.SELECT) .build()) .setUser("fred"); diff --git metastore/if/hive_metastore.thrift metastore/if/hive_metastore.thrift index f8e56c7..738456c 100755 --- metastore/if/hive_metastore.thrift +++ metastore/if/hive_metastore.thrift @@ -134,6 +134,15 @@ enum GrantRevokeType { REVOKE = 2, } +enum DataOperationType { + SELECT = 1, + INSERT = 2 + UPDATE = 3, + DELETE = 4, + UNSET = 5,//this is the default to distinguish from NULL from old clients + NO_TXN = 6,//drop table, insert overwrite, etc - something non-transactional +} + // Types of events the client can request that the metastore fire. For now just support DML operations, as the metastore knows // about DDL operations and there's no reason for the client to request such an event. enum EventRequestType { @@ -657,6 +666,8 @@ struct LockComponent { 3: required string dbname, 4: optional string tablename, 5: optional string partitionname, + 6: optional DataOperationType operationType = DataOperationType.UNSET, + 7: optional bool isAcid = false } struct LockRequest { @@ -762,6 +773,7 @@ struct AddDynamicPartitions { 2: required string dbname, 3: required string tablename, 4: required list partitionnames, + 5: optional DataOperationType operationType = DataOperationType.UNSET } struct NotificationEventRequest { diff --git metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 618c3ac..298384c 100644 --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size771; - ::apache::thrift::protocol::TType _etype774; - xfer += iprot->readListBegin(_etype774, _size771); - this->success.resize(_size771); - uint32_t _i775; - for (_i775 = 0; _i775 < _size771; ++_i775) + uint32_t _size773; + ::apache::thrift::protocol::TType _etype776; + xfer += iprot->readListBegin(_etype776, _size773); + this->success.resize(_size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - xfer += iprot->readString(this->success[_i775]); + xfer += iprot->readString(this->success[_i777]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter776; - for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776) + std::vector ::const_iterator _iter778; + for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) { - xfer += oprot->writeString((*_iter776)); + xfer += oprot->writeString((*_iter778)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size777; - ::apache::thrift::protocol::TType _etype780; - xfer += iprot->readListBegin(_etype780, _size777); - (*(this->success)).resize(_size777); - uint32_t _i781; - for (_i781 = 0; _i781 < _size777; ++_i781) + uint32_t _size779; + ::apache::thrift::protocol::TType _etype782; + xfer += iprot->readListBegin(_etype782, _size779); + (*(this->success)).resize(_size779); + uint32_t _i783; + for (_i783 = 0; _i783 < _size779; ++_i783) { - xfer += iprot->readString((*(this->success))[_i781]); + xfer += iprot->readString((*(this->success))[_i783]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size782; - ::apache::thrift::protocol::TType _etype785; - xfer += iprot->readListBegin(_etype785, _size782); - this->success.resize(_size782); - uint32_t _i786; - for (_i786 = 0; _i786 < _size782; ++_i786) + uint32_t _size784; + ::apache::thrift::protocol::TType _etype787; + xfer += iprot->readListBegin(_etype787, _size784); + this->success.resize(_size784); + uint32_t _i788; + for (_i788 = 0; _i788 < _size784; ++_i788) { - xfer += iprot->readString(this->success[_i786]); + xfer += iprot->readString(this->success[_i788]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter787; - for (_iter787 = this->success.begin(); _iter787 != this->success.end(); ++_iter787) + std::vector ::const_iterator _iter789; + for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) { - xfer += oprot->writeString((*_iter787)); + xfer += oprot->writeString((*_iter789)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size788; - ::apache::thrift::protocol::TType _etype791; - xfer += iprot->readListBegin(_etype791, _size788); - (*(this->success)).resize(_size788); - uint32_t _i792; - for (_i792 = 0; _i792 < _size788; ++_i792) + uint32_t _size790; + ::apache::thrift::protocol::TType _etype793; + xfer += iprot->readListBegin(_etype793, _size790); + (*(this->success)).resize(_size790); + uint32_t _i794; + for (_i794 = 0; _i794 < _size790; ++_i794) { - xfer += iprot->readString((*(this->success))[_i792]); + xfer += iprot->readString((*(this->success))[_i794]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size793; - ::apache::thrift::protocol::TType _ktype794; - ::apache::thrift::protocol::TType _vtype795; - xfer += iprot->readMapBegin(_ktype794, _vtype795, _size793); - uint32_t _i797; - for (_i797 = 0; _i797 < _size793; ++_i797) + uint32_t _size795; + ::apache::thrift::protocol::TType _ktype796; + ::apache::thrift::protocol::TType _vtype797; + xfer += iprot->readMapBegin(_ktype796, _vtype797, _size795); + uint32_t _i799; + for (_i799 = 0; _i799 < _size795; ++_i799) { - std::string _key798; - xfer += iprot->readString(_key798); - Type& _val799 = this->success[_key798]; - xfer += _val799.read(iprot); + std::string _key800; + xfer += iprot->readString(_key800); + Type& _val801 = this->success[_key800]; + xfer += _val801.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter800; - for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) + std::map ::const_iterator _iter802; + for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) { - xfer += oprot->writeString(_iter800->first); - xfer += _iter800->second.write(oprot); + xfer += oprot->writeString(_iter802->first); + xfer += _iter802->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size801; - ::apache::thrift::protocol::TType _ktype802; - ::apache::thrift::protocol::TType _vtype803; - xfer += iprot->readMapBegin(_ktype802, _vtype803, _size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size803; + ::apache::thrift::protocol::TType _ktype804; + ::apache::thrift::protocol::TType _vtype805; + xfer += iprot->readMapBegin(_ktype804, _vtype805, _size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - std::string _key806; - xfer += iprot->readString(_key806); - Type& _val807 = (*(this->success))[_key806]; - xfer += _val807.read(iprot); + std::string _key808; + xfer += iprot->readString(_key808); + Type& _val809 = (*(this->success))[_key808]; + xfer += _val809.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size808; - ::apache::thrift::protocol::TType _etype811; - xfer += iprot->readListBegin(_etype811, _size808); - this->success.resize(_size808); - uint32_t _i812; - for (_i812 = 0; _i812 < _size808; ++_i812) + uint32_t _size810; + ::apache::thrift::protocol::TType _etype813; + xfer += iprot->readListBegin(_etype813, _size810); + this->success.resize(_size810); + uint32_t _i814; + for (_i814 = 0; _i814 < _size810; ++_i814) { - xfer += this->success[_i812].read(iprot); + xfer += this->success[_i814].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter813; - for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) + std::vector ::const_iterator _iter815; + for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) { - xfer += (*_iter813).write(oprot); + xfer += (*_iter815).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size814; - ::apache::thrift::protocol::TType _etype817; - xfer += iprot->readListBegin(_etype817, _size814); - (*(this->success)).resize(_size814); - uint32_t _i818; - for (_i818 = 0; _i818 < _size814; ++_i818) + uint32_t _size816; + ::apache::thrift::protocol::TType _etype819; + xfer += iprot->readListBegin(_etype819, _size816); + (*(this->success)).resize(_size816); + uint32_t _i820; + for (_i820 = 0; _i820 < _size816; ++_i820) { - xfer += (*(this->success))[_i818].read(iprot); + xfer += (*(this->success))[_i820].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size819; - ::apache::thrift::protocol::TType _etype822; - xfer += iprot->readListBegin(_etype822, _size819); - this->success.resize(_size819); - uint32_t _i823; - for (_i823 = 0; _i823 < _size819; ++_i823) + uint32_t _size821; + ::apache::thrift::protocol::TType _etype824; + xfer += iprot->readListBegin(_etype824, _size821); + this->success.resize(_size821); + uint32_t _i825; + for (_i825 = 0; _i825 < _size821; ++_i825) { - xfer += this->success[_i823].read(iprot); + xfer += this->success[_i825].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter824; - for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) + std::vector ::const_iterator _iter826; + for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) { - xfer += (*_iter824).write(oprot); + xfer += (*_iter826).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size825; - ::apache::thrift::protocol::TType _etype828; - xfer += iprot->readListBegin(_etype828, _size825); - (*(this->success)).resize(_size825); - uint32_t _i829; - for (_i829 = 0; _i829 < _size825; ++_i829) + uint32_t _size827; + ::apache::thrift::protocol::TType _etype830; + xfer += iprot->readListBegin(_etype830, _size827); + (*(this->success)).resize(_size827); + uint32_t _i831; + for (_i831 = 0; _i831 < _size827; ++_i831) { - xfer += (*(this->success))[_i829].read(iprot); + xfer += (*(this->success))[_i831].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - this->success.resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size832; + ::apache::thrift::protocol::TType _etype835; + xfer += iprot->readListBegin(_etype835, _size832); + this->success.resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += this->success[_i834].read(iprot); + xfer += this->success[_i836].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter835; - for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835) + std::vector ::const_iterator _iter837; + for (_iter837 = this->success.begin(); _iter837 != this->success.end(); ++_iter837) { - xfer += (*_iter835).write(oprot); + xfer += (*_iter837).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size836; - ::apache::thrift::protocol::TType _etype839; - xfer += iprot->readListBegin(_etype839, _size836); - (*(this->success)).resize(_size836); - uint32_t _i840; - for (_i840 = 0; _i840 < _size836; ++_i840) + uint32_t _size838; + ::apache::thrift::protocol::TType _etype841; + xfer += iprot->readListBegin(_etype841, _size838); + (*(this->success)).resize(_size838); + uint32_t _i842; + for (_i842 = 0; _i842 < _size838; ++_i842) { - xfer += (*(this->success))[_i840].read(iprot); + xfer += (*(this->success))[_i842].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - this->success.resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + uint32_t _size843; + ::apache::thrift::protocol::TType _etype846; + xfer += iprot->readListBegin(_etype846, _size843); + this->success.resize(_size843); + uint32_t _i847; + for (_i847 = 0; _i847 < _size843; ++_i847) { - xfer += this->success[_i845].read(iprot); + xfer += this->success[_i847].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter846; - for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) + std::vector ::const_iterator _iter848; + for (_iter848 = this->success.begin(); _iter848 != this->success.end(); ++_iter848) { - xfer += (*_iter846).write(oprot); + xfer += (*_iter848).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size847; - ::apache::thrift::protocol::TType _etype850; - xfer += iprot->readListBegin(_etype850, _size847); - (*(this->success)).resize(_size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + uint32_t _size849; + ::apache::thrift::protocol::TType _etype852; + xfer += iprot->readListBegin(_etype852, _size849); + (*(this->success)).resize(_size849); + uint32_t _i853; + for (_i853 = 0; _i853 < _size849; ++_i853) { - xfer += (*(this->success))[_i851].read(iprot); + xfer += (*(this->success))[_i853].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size852; - ::apache::thrift::protocol::TType _etype855; - xfer += iprot->readListBegin(_etype855, _size852); - this->primaryKeys.resize(_size852); - uint32_t _i856; - for (_i856 = 0; _i856 < _size852; ++_i856) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->primaryKeys.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += this->primaryKeys[_i856].read(iprot); + xfer += this->primaryKeys[_i858].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size857; - ::apache::thrift::protocol::TType _etype860; - xfer += iprot->readListBegin(_etype860, _size857); - this->foreignKeys.resize(_size857); - uint32_t _i861; - for (_i861 = 0; _i861 < _size857; ++_i861) + uint32_t _size859; + ::apache::thrift::protocol::TType _etype862; + xfer += iprot->readListBegin(_etype862, _size859); + this->foreignKeys.resize(_size859); + uint32_t _i863; + for (_i863 = 0; _i863 < _size859; ++_i863) { - xfer += this->foreignKeys[_i861].read(iprot); + xfer += this->foreignKeys[_i863].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,10 +4578,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter862; - for (_iter862 = this->primaryKeys.begin(); _iter862 != this->primaryKeys.end(); ++_iter862) + std::vector ::const_iterator _iter864; + for (_iter864 = this->primaryKeys.begin(); _iter864 != this->primaryKeys.end(); ++_iter864) { - xfer += (*_iter862).write(oprot); + xfer += (*_iter864).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4590,10 +4590,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter863; - for (_iter863 = this->foreignKeys.begin(); _iter863 != this->foreignKeys.end(); ++_iter863) + std::vector ::const_iterator _iter865; + for (_iter865 = this->foreignKeys.begin(); _iter865 != this->foreignKeys.end(); ++_iter865) { - xfer += (*_iter863).write(oprot); + xfer += (*_iter865).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4621,10 +4621,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter864; - for (_iter864 = (*(this->primaryKeys)).begin(); _iter864 != (*(this->primaryKeys)).end(); ++_iter864) + std::vector ::const_iterator _iter866; + for (_iter866 = (*(this->primaryKeys)).begin(); _iter866 != (*(this->primaryKeys)).end(); ++_iter866) { - xfer += (*_iter864).write(oprot); + xfer += (*_iter866).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4633,10 +4633,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter865; - for (_iter865 = (*(this->foreignKeys)).begin(); _iter865 != (*(this->foreignKeys)).end(); ++_iter865) + std::vector ::const_iterator _iter867; + for (_iter867 = (*(this->foreignKeys)).begin(); _iter867 != (*(this->foreignKeys)).end(); ++_iter867) { - xfer += (*_iter865).write(oprot); + xfer += (*_iter867).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6055,14 +6055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size866; - ::apache::thrift::protocol::TType _etype869; - xfer += iprot->readListBegin(_etype869, _size866); - this->success.resize(_size866); - uint32_t _i870; - for (_i870 = 0; _i870 < _size866; ++_i870) + uint32_t _size868; + ::apache::thrift::protocol::TType _etype871; + xfer += iprot->readListBegin(_etype871, _size868); + this->success.resize(_size868); + uint32_t _i872; + for (_i872 = 0; _i872 < _size868; ++_i872) { - xfer += iprot->readString(this->success[_i870]); + xfer += iprot->readString(this->success[_i872]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6101,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter871; - for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) + std::vector ::const_iterator _iter873; + for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) { - xfer += oprot->writeString((*_iter871)); + xfer += oprot->writeString((*_iter873)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size872; - ::apache::thrift::protocol::TType _etype875; - xfer += iprot->readListBegin(_etype875, _size872); - (*(this->success)).resize(_size872); - uint32_t _i876; - for (_i876 = 0; _i876 < _size872; ++_i876) + uint32_t _size874; + ::apache::thrift::protocol::TType _etype877; + xfer += iprot->readListBegin(_etype877, _size874); + (*(this->success)).resize(_size874); + uint32_t _i878; + for (_i878 = 0; _i878 < _size874; ++_i878) { - xfer += iprot->readString((*(this->success))[_i876]); + xfer += iprot->readString((*(this->success))[_i878]); } xfer += iprot->readListEnd(); } @@ -6231,14 +6231,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - this->tbl_types.resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + uint32_t _size879; + ::apache::thrift::protocol::TType _etype882; + xfer += iprot->readListBegin(_etype882, _size879); + this->tbl_types.resize(_size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - xfer += iprot->readString(this->tbl_types[_i881]); + xfer += iprot->readString(this->tbl_types[_i883]); } xfer += iprot->readListEnd(); } @@ -6275,10 +6275,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); - std::vector ::const_iterator _iter882; - for (_iter882 = this->tbl_types.begin(); _iter882 != this->tbl_types.end(); ++_iter882) + std::vector ::const_iterator _iter884; + for (_iter884 = this->tbl_types.begin(); _iter884 != this->tbl_types.end(); ++_iter884) { - xfer += oprot->writeString((*_iter882)); + xfer += oprot->writeString((*_iter884)); } xfer += oprot->writeListEnd(); } @@ -6310,10 +6310,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter883; - for (_iter883 = (*(this->tbl_types)).begin(); _iter883 != (*(this->tbl_types)).end(); ++_iter883) + std::vector ::const_iterator _iter885; + for (_iter885 = (*(this->tbl_types)).begin(); _iter885 != (*(this->tbl_types)).end(); ++_iter885) { - xfer += oprot->writeString((*_iter883)); + xfer += oprot->writeString((*_iter885)); } xfer += oprot->writeListEnd(); } @@ -6354,14 +6354,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size884; - ::apache::thrift::protocol::TType _etype887; - xfer += iprot->readListBegin(_etype887, _size884); - this->success.resize(_size884); - uint32_t _i888; - for (_i888 = 0; _i888 < _size884; ++_i888) + uint32_t _size886; + ::apache::thrift::protocol::TType _etype889; + xfer += iprot->readListBegin(_etype889, _size886); + this->success.resize(_size886); + uint32_t _i890; + for (_i890 = 0; _i890 < _size886; ++_i890) { - xfer += this->success[_i888].read(iprot); + xfer += this->success[_i890].read(iprot); } xfer += iprot->readListEnd(); } @@ -6400,10 +6400,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter889; - for (_iter889 = this->success.begin(); _iter889 != this->success.end(); ++_iter889) + std::vector ::const_iterator _iter891; + for (_iter891 = this->success.begin(); _iter891 != this->success.end(); ++_iter891) { - xfer += (*_iter889).write(oprot); + xfer += (*_iter891).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6448,14 +6448,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size890; - ::apache::thrift::protocol::TType _etype893; - xfer += iprot->readListBegin(_etype893, _size890); - (*(this->success)).resize(_size890); - uint32_t _i894; - for (_i894 = 0; _i894 < _size890; ++_i894) + uint32_t _size892; + ::apache::thrift::protocol::TType _etype895; + xfer += iprot->readListBegin(_etype895, _size892); + (*(this->success)).resize(_size892); + uint32_t _i896; + for (_i896 = 0; _i896 < _size892; ++_i896) { - xfer += (*(this->success))[_i894].read(iprot); + xfer += (*(this->success))[_i896].read(iprot); } xfer += iprot->readListEnd(); } @@ -6593,14 +6593,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size895; - ::apache::thrift::protocol::TType _etype898; - xfer += iprot->readListBegin(_etype898, _size895); - this->success.resize(_size895); - uint32_t _i899; - for (_i899 = 0; _i899 < _size895; ++_i899) + uint32_t _size897; + ::apache::thrift::protocol::TType _etype900; + xfer += iprot->readListBegin(_etype900, _size897); + this->success.resize(_size897); + uint32_t _i901; + for (_i901 = 0; _i901 < _size897; ++_i901) { - xfer += iprot->readString(this->success[_i899]); + xfer += iprot->readString(this->success[_i901]); } xfer += iprot->readListEnd(); } @@ -6639,10 +6639,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter900; - for (_iter900 = this->success.begin(); _iter900 != this->success.end(); ++_iter900) + std::vector ::const_iterator _iter902; + for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) { - xfer += oprot->writeString((*_iter900)); + xfer += oprot->writeString((*_iter902)); } xfer += oprot->writeListEnd(); } @@ -6687,14 +6687,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size901; - ::apache::thrift::protocol::TType _etype904; - xfer += iprot->readListBegin(_etype904, _size901); - (*(this->success)).resize(_size901); - uint32_t _i905; - for (_i905 = 0; _i905 < _size901; ++_i905) + uint32_t _size903; + ::apache::thrift::protocol::TType _etype906; + xfer += iprot->readListBegin(_etype906, _size903); + (*(this->success)).resize(_size903); + uint32_t _i907; + for (_i907 = 0; _i907 < _size903; ++_i907) { - xfer += iprot->readString((*(this->success))[_i905]); + xfer += iprot->readString((*(this->success))[_i907]); } xfer += iprot->readListEnd(); } @@ -7004,14 +7004,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size906; - ::apache::thrift::protocol::TType _etype909; - xfer += iprot->readListBegin(_etype909, _size906); - this->tbl_names.resize(_size906); - uint32_t _i910; - for (_i910 = 0; _i910 < _size906; ++_i910) + uint32_t _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + this->tbl_names.resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString(this->tbl_names[_i910]); + xfer += iprot->readString(this->tbl_names[_i912]); } xfer += iprot->readListEnd(); } @@ -7044,10 +7044,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter911; - for (_iter911 = this->tbl_names.begin(); _iter911 != this->tbl_names.end(); ++_iter911) + std::vector ::const_iterator _iter913; + for (_iter913 = this->tbl_names.begin(); _iter913 != this->tbl_names.end(); ++_iter913) { - xfer += oprot->writeString((*_iter911)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -7075,10 +7075,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter912; - for (_iter912 = (*(this->tbl_names)).begin(); _iter912 != (*(this->tbl_names)).end(); ++_iter912) + std::vector ::const_iterator _iter914; + for (_iter914 = (*(this->tbl_names)).begin(); _iter914 != (*(this->tbl_names)).end(); ++_iter914) { - xfer += oprot->writeString((*_iter912)); + xfer += oprot->writeString((*_iter914)); } xfer += oprot->writeListEnd(); } @@ -7119,14 +7119,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->success.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + this->success.resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += this->success[_i917].read(iprot); + xfer += this->success[_i919].read(iprot); } xfer += iprot->readListEnd(); } @@ -7181,10 +7181,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector
::const_iterator _iter920; + for (_iter920 = this->success.begin(); _iter920 != this->success.end(); ++_iter920) { - xfer += (*_iter918).write(oprot); + xfer += (*_iter920).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7237,14 +7237,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size921; + ::apache::thrift::protocol::TType _etype924; + xfer += iprot->readListBegin(_etype924, _size921); + (*(this->success)).resize(_size921); + uint32_t _i925; + for (_i925 = 0; _i925 < _size921; ++_i925) { - xfer += (*(this->success))[_i923].read(iprot); + xfer += (*(this->success))[_i925].read(iprot); } xfer += iprot->readListEnd(); } @@ -7430,14 +7430,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - this->success.resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + this->success.resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += iprot->readString(this->success[_i928]); + xfer += iprot->readString(this->success[_i930]); } xfer += iprot->readListEnd(); } @@ -7492,10 +7492,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter929; - for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) + std::vector ::const_iterator _iter931; + for (_iter931 = this->success.begin(); _iter931 != this->success.end(); ++_iter931) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter931)); } xfer += oprot->writeListEnd(); } @@ -7548,14 +7548,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size930; - ::apache::thrift::protocol::TType _etype933; - xfer += iprot->readListBegin(_etype933, _size930); - (*(this->success)).resize(_size930); - uint32_t _i934; - for (_i934 = 0; _i934 < _size930; ++_i934) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + (*(this->success)).resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += iprot->readString((*(this->success))[_i934]); + xfer += iprot->readString((*(this->success))[_i936]); } xfer += iprot->readListEnd(); } @@ -8889,14 +8889,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->new_parts.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size937; + ::apache::thrift::protocol::TType _etype940; + xfer += iprot->readListBegin(_etype940, _size937); + this->new_parts.resize(_size937); + uint32_t _i941; + for (_i941 = 0; _i941 < _size937; ++_i941) { - xfer += this->new_parts[_i939].read(iprot); + xfer += this->new_parts[_i941].read(iprot); } xfer += iprot->readListEnd(); } @@ -8925,10 +8925,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter940; - for (_iter940 = this->new_parts.begin(); _iter940 != this->new_parts.end(); ++_iter940) + std::vector ::const_iterator _iter942; + for (_iter942 = this->new_parts.begin(); _iter942 != this->new_parts.end(); ++_iter942) { - xfer += (*_iter940).write(oprot); + xfer += (*_iter942).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8952,10 +8952,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter941; - for (_iter941 = (*(this->new_parts)).begin(); _iter941 != (*(this->new_parts)).end(); ++_iter941) + std::vector ::const_iterator _iter943; + for (_iter943 = (*(this->new_parts)).begin(); _iter943 != (*(this->new_parts)).end(); ++_iter943) { - xfer += (*_iter941).write(oprot); + xfer += (*_iter943).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9164,14 +9164,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->new_parts.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + this->new_parts.resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += this->new_parts[_i946].read(iprot); + xfer += this->new_parts[_i948].read(iprot); } xfer += iprot->readListEnd(); } @@ -9200,10 +9200,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter947; - for (_iter947 = this->new_parts.begin(); _iter947 != this->new_parts.end(); ++_iter947) + std::vector ::const_iterator _iter949; + for (_iter949 = this->new_parts.begin(); _iter949 != this->new_parts.end(); ++_iter949) { - xfer += (*_iter947).write(oprot); + xfer += (*_iter949).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9227,10 +9227,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter948; - for (_iter948 = (*(this->new_parts)).begin(); _iter948 != (*(this->new_parts)).end(); ++_iter948) + std::vector ::const_iterator _iter950; + for (_iter950 = (*(this->new_parts)).begin(); _iter950 != (*(this->new_parts)).end(); ++_iter950) { - xfer += (*_iter948).write(oprot); + xfer += (*_iter950).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9455,14 +9455,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - this->part_vals.resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + uint32_t _size951; + ::apache::thrift::protocol::TType _etype954; + xfer += iprot->readListBegin(_etype954, _size951); + this->part_vals.resize(_size951); + uint32_t _i955; + for (_i955 = 0; _i955 < _size951; ++_i955) { - xfer += iprot->readString(this->part_vals[_i953]); + xfer += iprot->readString(this->part_vals[_i955]); } xfer += iprot->readListEnd(); } @@ -9499,10 +9499,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter954; - for (_iter954 = this->part_vals.begin(); _iter954 != this->part_vals.end(); ++_iter954) + std::vector ::const_iterator _iter956; + for (_iter956 = this->part_vals.begin(); _iter956 != this->part_vals.end(); ++_iter956) { - xfer += oprot->writeString((*_iter954)); + xfer += oprot->writeString((*_iter956)); } xfer += oprot->writeListEnd(); } @@ -9534,10 +9534,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter955; - for (_iter955 = (*(this->part_vals)).begin(); _iter955 != (*(this->part_vals)).end(); ++_iter955) + std::vector ::const_iterator _iter957; + for (_iter957 = (*(this->part_vals)).begin(); _iter957 != (*(this->part_vals)).end(); ++_iter957) { - xfer += oprot->writeString((*_iter955)); + xfer += oprot->writeString((*_iter957)); } xfer += oprot->writeListEnd(); } @@ -10009,14 +10009,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size956; - ::apache::thrift::protocol::TType _etype959; - xfer += iprot->readListBegin(_etype959, _size956); - this->part_vals.resize(_size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + uint32_t _size958; + ::apache::thrift::protocol::TType _etype961; + xfer += iprot->readListBegin(_etype961, _size958); + this->part_vals.resize(_size958); + uint32_t _i962; + for (_i962 = 0; _i962 < _size958; ++_i962) { - xfer += iprot->readString(this->part_vals[_i960]); + xfer += iprot->readString(this->part_vals[_i962]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10061,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter961; - for (_iter961 = this->part_vals.begin(); _iter961 != this->part_vals.end(); ++_iter961) + std::vector ::const_iterator _iter963; + for (_iter963 = this->part_vals.begin(); _iter963 != this->part_vals.end(); ++_iter963) { - xfer += oprot->writeString((*_iter961)); + xfer += oprot->writeString((*_iter963)); } xfer += oprot->writeListEnd(); } @@ -10100,10 +10100,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter962; - for (_iter962 = (*(this->part_vals)).begin(); _iter962 != (*(this->part_vals)).end(); ++_iter962) + std::vector ::const_iterator _iter964; + for (_iter964 = (*(this->part_vals)).begin(); _iter964 != (*(this->part_vals)).end(); ++_iter964) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter964)); } xfer += oprot->writeListEnd(); } @@ -10906,14 +10906,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size963; - ::apache::thrift::protocol::TType _etype966; - xfer += iprot->readListBegin(_etype966, _size963); - this->part_vals.resize(_size963); - uint32_t _i967; - for (_i967 = 0; _i967 < _size963; ++_i967) + uint32_t _size965; + ::apache::thrift::protocol::TType _etype968; + xfer += iprot->readListBegin(_etype968, _size965); + this->part_vals.resize(_size965); + uint32_t _i969; + for (_i969 = 0; _i969 < _size965; ++_i969) { - xfer += iprot->readString(this->part_vals[_i967]); + xfer += iprot->readString(this->part_vals[_i969]); } xfer += iprot->readListEnd(); } @@ -10958,10 +10958,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter968; - for (_iter968 = this->part_vals.begin(); _iter968 != this->part_vals.end(); ++_iter968) + std::vector ::const_iterator _iter970; + for (_iter970 = this->part_vals.begin(); _iter970 != this->part_vals.end(); ++_iter970) { - xfer += oprot->writeString((*_iter968)); + xfer += oprot->writeString((*_iter970)); } xfer += oprot->writeListEnd(); } @@ -10997,10 +10997,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter969; - for (_iter969 = (*(this->part_vals)).begin(); _iter969 != (*(this->part_vals)).end(); ++_iter969) + std::vector ::const_iterator _iter971; + for (_iter971 = (*(this->part_vals)).begin(); _iter971 != (*(this->part_vals)).end(); ++_iter971) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -11209,14 +11209,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size970; - ::apache::thrift::protocol::TType _etype973; - xfer += iprot->readListBegin(_etype973, _size970); - this->part_vals.resize(_size970); - uint32_t _i974; - for (_i974 = 0; _i974 < _size970; ++_i974) + uint32_t _size972; + ::apache::thrift::protocol::TType _etype975; + xfer += iprot->readListBegin(_etype975, _size972); + this->part_vals.resize(_size972); + uint32_t _i976; + for (_i976 = 0; _i976 < _size972; ++_i976) { - xfer += iprot->readString(this->part_vals[_i974]); + xfer += iprot->readString(this->part_vals[_i976]); } xfer += iprot->readListEnd(); } @@ -11269,10 +11269,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter975; - for (_iter975 = this->part_vals.begin(); _iter975 != this->part_vals.end(); ++_iter975) + std::vector ::const_iterator _iter977; + for (_iter977 = this->part_vals.begin(); _iter977 != this->part_vals.end(); ++_iter977) { - xfer += oprot->writeString((*_iter975)); + xfer += oprot->writeString((*_iter977)); } xfer += oprot->writeListEnd(); } @@ -11312,10 +11312,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter976; - for (_iter976 = (*(this->part_vals)).begin(); _iter976 != (*(this->part_vals)).end(); ++_iter976) + std::vector ::const_iterator _iter978; + for (_iter978 = (*(this->part_vals)).begin(); _iter978 != (*(this->part_vals)).end(); ++_iter978) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter978)); } xfer += oprot->writeListEnd(); } @@ -12321,14 +12321,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - this->part_vals.resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size979; + ::apache::thrift::protocol::TType _etype982; + xfer += iprot->readListBegin(_etype982, _size979); + this->part_vals.resize(_size979); + uint32_t _i983; + for (_i983 = 0; _i983 < _size979; ++_i983) { - xfer += iprot->readString(this->part_vals[_i981]); + xfer += iprot->readString(this->part_vals[_i983]); } xfer += iprot->readListEnd(); } @@ -12365,10 +12365,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter982; - for (_iter982 = this->part_vals.begin(); _iter982 != this->part_vals.end(); ++_iter982) + std::vector ::const_iterator _iter984; + for (_iter984 = this->part_vals.begin(); _iter984 != this->part_vals.end(); ++_iter984) { - xfer += oprot->writeString((*_iter982)); + xfer += oprot->writeString((*_iter984)); } xfer += oprot->writeListEnd(); } @@ -12400,10 +12400,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter983; - for (_iter983 = (*(this->part_vals)).begin(); _iter983 != (*(this->part_vals)).end(); ++_iter983) + std::vector ::const_iterator _iter985; + for (_iter985 = (*(this->part_vals)).begin(); _iter985 != (*(this->part_vals)).end(); ++_iter985) { - xfer += oprot->writeString((*_iter983)); + xfer += oprot->writeString((*_iter985)); } xfer += oprot->writeListEnd(); } @@ -12592,17 +12592,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size984; - ::apache::thrift::protocol::TType _ktype985; - ::apache::thrift::protocol::TType _vtype986; - xfer += iprot->readMapBegin(_ktype985, _vtype986, _size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size986; + ::apache::thrift::protocol::TType _ktype987; + ::apache::thrift::protocol::TType _vtype988; + xfer += iprot->readMapBegin(_ktype987, _vtype988, _size986); + uint32_t _i990; + for (_i990 = 0; _i990 < _size986; ++_i990) { - std::string _key989; - xfer += iprot->readString(_key989); - std::string& _val990 = this->partitionSpecs[_key989]; - xfer += iprot->readString(_val990); + std::string _key991; + xfer += iprot->readString(_key991); + std::string& _val992 = this->partitionSpecs[_key991]; + xfer += iprot->readString(_val992); } xfer += iprot->readMapEnd(); } @@ -12663,11 +12663,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter991; - for (_iter991 = this->partitionSpecs.begin(); _iter991 != this->partitionSpecs.end(); ++_iter991) + std::map ::const_iterator _iter993; + for (_iter993 = this->partitionSpecs.begin(); _iter993 != this->partitionSpecs.end(); ++_iter993) { - xfer += oprot->writeString(_iter991->first); - xfer += oprot->writeString(_iter991->second); + xfer += oprot->writeString(_iter993->first); + xfer += oprot->writeString(_iter993->second); } xfer += oprot->writeMapEnd(); } @@ -12707,11 +12707,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter992; - for (_iter992 = (*(this->partitionSpecs)).begin(); _iter992 != (*(this->partitionSpecs)).end(); ++_iter992) + std::map ::const_iterator _iter994; + for (_iter994 = (*(this->partitionSpecs)).begin(); _iter994 != (*(this->partitionSpecs)).end(); ++_iter994) { - xfer += oprot->writeString(_iter992->first); - xfer += oprot->writeString(_iter992->second); + xfer += oprot->writeString(_iter994->first); + xfer += oprot->writeString(_iter994->second); } xfer += oprot->writeMapEnd(); } @@ -12956,17 +12956,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _ktype994; - ::apache::thrift::protocol::TType _vtype995; - xfer += iprot->readMapBegin(_ktype994, _vtype995, _size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size995; + ::apache::thrift::protocol::TType _ktype996; + ::apache::thrift::protocol::TType _vtype997; + xfer += iprot->readMapBegin(_ktype996, _vtype997, _size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - std::string _key998; - xfer += iprot->readString(_key998); - std::string& _val999 = this->partitionSpecs[_key998]; - xfer += iprot->readString(_val999); + std::string _key1000; + xfer += iprot->readString(_key1000); + std::string& _val1001 = this->partitionSpecs[_key1000]; + xfer += iprot->readString(_val1001); } xfer += iprot->readMapEnd(); } @@ -13027,11 +13027,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1000; - for (_iter1000 = this->partitionSpecs.begin(); _iter1000 != this->partitionSpecs.end(); ++_iter1000) + std::map ::const_iterator _iter1002; + for (_iter1002 = this->partitionSpecs.begin(); _iter1002 != this->partitionSpecs.end(); ++_iter1002) { - xfer += oprot->writeString(_iter1000->first); - xfer += oprot->writeString(_iter1000->second); + xfer += oprot->writeString(_iter1002->first); + xfer += oprot->writeString(_iter1002->second); } xfer += oprot->writeMapEnd(); } @@ -13071,11 +13071,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1001; - for (_iter1001 = (*(this->partitionSpecs)).begin(); _iter1001 != (*(this->partitionSpecs)).end(); ++_iter1001) + std::map ::const_iterator _iter1003; + for (_iter1003 = (*(this->partitionSpecs)).begin(); _iter1003 != (*(this->partitionSpecs)).end(); ++_iter1003) { - xfer += oprot->writeString(_iter1001->first); - xfer += oprot->writeString(_iter1001->second); + xfer += oprot->writeString(_iter1003->first); + xfer += oprot->writeString(_iter1003->second); } xfer += oprot->writeMapEnd(); } @@ -13132,14 +13132,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1002; - ::apache::thrift::protocol::TType _etype1005; - xfer += iprot->readListBegin(_etype1005, _size1002); - this->success.resize(_size1002); - uint32_t _i1006; - for (_i1006 = 0; _i1006 < _size1002; ++_i1006) + uint32_t _size1004; + ::apache::thrift::protocol::TType _etype1007; + xfer += iprot->readListBegin(_etype1007, _size1004); + this->success.resize(_size1004); + uint32_t _i1008; + for (_i1008 = 0; _i1008 < _size1004; ++_i1008) { - xfer += this->success[_i1006].read(iprot); + xfer += this->success[_i1008].read(iprot); } xfer += iprot->readListEnd(); } @@ -13202,10 +13202,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1007; - for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007) + std::vector ::const_iterator _iter1009; + for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) { - xfer += (*_iter1007).write(oprot); + xfer += (*_iter1009).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13262,14 +13262,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1008; - ::apache::thrift::protocol::TType _etype1011; - xfer += iprot->readListBegin(_etype1011, _size1008); - (*(this->success)).resize(_size1008); - uint32_t _i1012; - for (_i1012 = 0; _i1012 < _size1008; ++_i1012) + uint32_t _size1010; + ::apache::thrift::protocol::TType _etype1013; + xfer += iprot->readListBegin(_etype1013, _size1010); + (*(this->success)).resize(_size1010); + uint32_t _i1014; + for (_i1014 = 0; _i1014 < _size1010; ++_i1014) { - xfer += (*(this->success))[_i1012].read(iprot); + xfer += (*(this->success))[_i1014].read(iprot); } xfer += iprot->readListEnd(); } @@ -13368,14 +13368,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1013; - ::apache::thrift::protocol::TType _etype1016; - xfer += iprot->readListBegin(_etype1016, _size1013); - this->part_vals.resize(_size1013); - uint32_t _i1017; - for (_i1017 = 0; _i1017 < _size1013; ++_i1017) + uint32_t _size1015; + ::apache::thrift::protocol::TType _etype1018; + xfer += iprot->readListBegin(_etype1018, _size1015); + this->part_vals.resize(_size1015); + uint32_t _i1019; + for (_i1019 = 0; _i1019 < _size1015; ++_i1019) { - xfer += iprot->readString(this->part_vals[_i1017]); + xfer += iprot->readString(this->part_vals[_i1019]); } xfer += iprot->readListEnd(); } @@ -13396,14 +13396,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - this->group_names.resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1020; + ::apache::thrift::protocol::TType _etype1023; + xfer += iprot->readListBegin(_etype1023, _size1020); + this->group_names.resize(_size1020); + uint32_t _i1024; + for (_i1024 = 0; _i1024 < _size1020; ++_i1024) { - xfer += iprot->readString(this->group_names[_i1022]); + xfer += iprot->readString(this->group_names[_i1024]); } xfer += iprot->readListEnd(); } @@ -13440,10 +13440,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1023; - for (_iter1023 = this->part_vals.begin(); _iter1023 != this->part_vals.end(); ++_iter1023) + std::vector ::const_iterator _iter1025; + for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) { - xfer += oprot->writeString((*_iter1023)); + xfer += oprot->writeString((*_iter1025)); } xfer += oprot->writeListEnd(); } @@ -13456,10 +13456,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1024; - for (_iter1024 = this->group_names.begin(); _iter1024 != this->group_names.end(); ++_iter1024) + std::vector ::const_iterator _iter1026; + for (_iter1026 = this->group_names.begin(); _iter1026 != this->group_names.end(); ++_iter1026) { - xfer += oprot->writeString((*_iter1024)); + xfer += oprot->writeString((*_iter1026)); } xfer += oprot->writeListEnd(); } @@ -13491,10 +13491,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1025; - for (_iter1025 = (*(this->part_vals)).begin(); _iter1025 != (*(this->part_vals)).end(); ++_iter1025) + std::vector ::const_iterator _iter1027; + for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) { - xfer += oprot->writeString((*_iter1025)); + xfer += oprot->writeString((*_iter1027)); } xfer += oprot->writeListEnd(); } @@ -13507,10 +13507,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1026; - for (_iter1026 = (*(this->group_names)).begin(); _iter1026 != (*(this->group_names)).end(); ++_iter1026) + std::vector ::const_iterator _iter1028; + for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1028)); } xfer += oprot->writeListEnd(); } @@ -14069,14 +14069,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1027; - ::apache::thrift::protocol::TType _etype1030; - xfer += iprot->readListBegin(_etype1030, _size1027); - this->success.resize(_size1027); - uint32_t _i1031; - for (_i1031 = 0; _i1031 < _size1027; ++_i1031) + uint32_t _size1029; + ::apache::thrift::protocol::TType _etype1032; + xfer += iprot->readListBegin(_etype1032, _size1029); + this->success.resize(_size1029); + uint32_t _i1033; + for (_i1033 = 0; _i1033 < _size1029; ++_i1033) { - xfer += this->success[_i1031].read(iprot); + xfer += this->success[_i1033].read(iprot); } xfer += iprot->readListEnd(); } @@ -14123,10 +14123,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1032; - for (_iter1032 = this->success.begin(); _iter1032 != this->success.end(); ++_iter1032) + std::vector ::const_iterator _iter1034; + for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034) { - xfer += (*_iter1032).write(oprot); + xfer += (*_iter1034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14175,14 +14175,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1033; - ::apache::thrift::protocol::TType _etype1036; - xfer += iprot->readListBegin(_etype1036, _size1033); - (*(this->success)).resize(_size1033); - uint32_t _i1037; - for (_i1037 = 0; _i1037 < _size1033; ++_i1037) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + (*(this->success)).resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += (*(this->success))[_i1037].read(iprot); + xfer += (*(this->success))[_i1039].read(iprot); } xfer += iprot->readListEnd(); } @@ -14281,14 +14281,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1038; - ::apache::thrift::protocol::TType _etype1041; - xfer += iprot->readListBegin(_etype1041, _size1038); - this->group_names.resize(_size1038); - uint32_t _i1042; - for (_i1042 = 0; _i1042 < _size1038; ++_i1042) + uint32_t _size1040; + ::apache::thrift::protocol::TType _etype1043; + xfer += iprot->readListBegin(_etype1043, _size1040); + this->group_names.resize(_size1040); + uint32_t _i1044; + for (_i1044 = 0; _i1044 < _size1040; ++_i1044) { - xfer += iprot->readString(this->group_names[_i1042]); + xfer += iprot->readString(this->group_names[_i1044]); } xfer += iprot->readListEnd(); } @@ -14333,10 +14333,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1043; - for (_iter1043 = this->group_names.begin(); _iter1043 != this->group_names.end(); ++_iter1043) + std::vector ::const_iterator _iter1045; + for (_iter1045 = this->group_names.begin(); _iter1045 != this->group_names.end(); ++_iter1045) { - xfer += oprot->writeString((*_iter1043)); + xfer += oprot->writeString((*_iter1045)); } xfer += oprot->writeListEnd(); } @@ -14376,10 +14376,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1044; - for (_iter1044 = (*(this->group_names)).begin(); _iter1044 != (*(this->group_names)).end(); ++_iter1044) + std::vector ::const_iterator _iter1046; + for (_iter1046 = (*(this->group_names)).begin(); _iter1046 != (*(this->group_names)).end(); ++_iter1046) { - xfer += oprot->writeString((*_iter1044)); + xfer += oprot->writeString((*_iter1046)); } xfer += oprot->writeListEnd(); } @@ -14420,14 +14420,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1045; - ::apache::thrift::protocol::TType _etype1048; - xfer += iprot->readListBegin(_etype1048, _size1045); - this->success.resize(_size1045); - uint32_t _i1049; - for (_i1049 = 0; _i1049 < _size1045; ++_i1049) + uint32_t _size1047; + ::apache::thrift::protocol::TType _etype1050; + xfer += iprot->readListBegin(_etype1050, _size1047); + this->success.resize(_size1047); + uint32_t _i1051; + for (_i1051 = 0; _i1051 < _size1047; ++_i1051) { - xfer += this->success[_i1049].read(iprot); + xfer += this->success[_i1051].read(iprot); } xfer += iprot->readListEnd(); } @@ -14474,10 +14474,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1050; - for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) + std::vector ::const_iterator _iter1052; + for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) { - xfer += (*_iter1050).write(oprot); + xfer += (*_iter1052).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14526,14 +14526,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - (*(this->success)).resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1053; + ::apache::thrift::protocol::TType _etype1056; + xfer += iprot->readListBegin(_etype1056, _size1053); + (*(this->success)).resize(_size1053); + uint32_t _i1057; + for (_i1057 = 0; _i1057 < _size1053; ++_i1057) { - xfer += (*(this->success))[_i1055].read(iprot); + xfer += (*(this->success))[_i1057].read(iprot); } xfer += iprot->readListEnd(); } @@ -14711,14 +14711,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->success.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1058; + ::apache::thrift::protocol::TType _etype1061; + xfer += iprot->readListBegin(_etype1061, _size1058); + this->success.resize(_size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - xfer += this->success[_i1060].read(iprot); + xfer += this->success[_i1062].read(iprot); } xfer += iprot->readListEnd(); } @@ -14765,10 +14765,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1061; - for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061) + std::vector ::const_iterator _iter1063; + for (_iter1063 = this->success.begin(); _iter1063 != this->success.end(); ++_iter1063) { - xfer += (*_iter1061).write(oprot); + xfer += (*_iter1063).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14817,14 +14817,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1062; - ::apache::thrift::protocol::TType _etype1065; - xfer += iprot->readListBegin(_etype1065, _size1062); - (*(this->success)).resize(_size1062); - uint32_t _i1066; - for (_i1066 = 0; _i1066 < _size1062; ++_i1066) + uint32_t _size1064; + ::apache::thrift::protocol::TType _etype1067; + xfer += iprot->readListBegin(_etype1067, _size1064); + (*(this->success)).resize(_size1064); + uint32_t _i1068; + for (_i1068 = 0; _i1068 < _size1064; ++_i1068) { - xfer += (*(this->success))[_i1066].read(iprot); + xfer += (*(this->success))[_i1068].read(iprot); } xfer += iprot->readListEnd(); } @@ -15002,14 +15002,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->success.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1069; + ::apache::thrift::protocol::TType _etype1072; + xfer += iprot->readListBegin(_etype1072, _size1069); + this->success.resize(_size1069); + uint32_t _i1073; + for (_i1073 = 0; _i1073 < _size1069; ++_i1073) { - xfer += iprot->readString(this->success[_i1071]); + xfer += iprot->readString(this->success[_i1073]); } xfer += iprot->readListEnd(); } @@ -15048,10 +15048,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1072; - for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) + std::vector ::const_iterator _iter1074; + for (_iter1074 = this->success.begin(); _iter1074 != this->success.end(); ++_iter1074) { - xfer += oprot->writeString((*_iter1072)); + xfer += oprot->writeString((*_iter1074)); } xfer += oprot->writeListEnd(); } @@ -15096,14 +15096,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1073; - ::apache::thrift::protocol::TType _etype1076; - xfer += iprot->readListBegin(_etype1076, _size1073); - (*(this->success)).resize(_size1073); - uint32_t _i1077; - for (_i1077 = 0; _i1077 < _size1073; ++_i1077) + uint32_t _size1075; + ::apache::thrift::protocol::TType _etype1078; + xfer += iprot->readListBegin(_etype1078, _size1075); + (*(this->success)).resize(_size1075); + uint32_t _i1079; + for (_i1079 = 0; _i1079 < _size1075; ++_i1079) { - xfer += iprot->readString((*(this->success))[_i1077]); + xfer += iprot->readString((*(this->success))[_i1079]); } xfer += iprot->readListEnd(); } @@ -15178,14 +15178,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1078; - ::apache::thrift::protocol::TType _etype1081; - xfer += iprot->readListBegin(_etype1081, _size1078); - this->part_vals.resize(_size1078); - uint32_t _i1082; - for (_i1082 = 0; _i1082 < _size1078; ++_i1082) + uint32_t _size1080; + ::apache::thrift::protocol::TType _etype1083; + xfer += iprot->readListBegin(_etype1083, _size1080); + this->part_vals.resize(_size1080); + uint32_t _i1084; + for (_i1084 = 0; _i1084 < _size1080; ++_i1084) { - xfer += iprot->readString(this->part_vals[_i1082]); + xfer += iprot->readString(this->part_vals[_i1084]); } xfer += iprot->readListEnd(); } @@ -15230,10 +15230,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1083; - for (_iter1083 = this->part_vals.begin(); _iter1083 != this->part_vals.end(); ++_iter1083) + std::vector ::const_iterator _iter1085; + for (_iter1085 = this->part_vals.begin(); _iter1085 != this->part_vals.end(); ++_iter1085) { - xfer += oprot->writeString((*_iter1083)); + xfer += oprot->writeString((*_iter1085)); } xfer += oprot->writeListEnd(); } @@ -15269,10 +15269,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1084; - for (_iter1084 = (*(this->part_vals)).begin(); _iter1084 != (*(this->part_vals)).end(); ++_iter1084) + std::vector ::const_iterator _iter1086; + for (_iter1086 = (*(this->part_vals)).begin(); _iter1086 != (*(this->part_vals)).end(); ++_iter1086) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1086)); } xfer += oprot->writeListEnd(); } @@ -15317,14 +15317,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1085; - ::apache::thrift::protocol::TType _etype1088; - xfer += iprot->readListBegin(_etype1088, _size1085); - this->success.resize(_size1085); - uint32_t _i1089; - for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + uint32_t _size1087; + ::apache::thrift::protocol::TType _etype1090; + xfer += iprot->readListBegin(_etype1090, _size1087); + this->success.resize(_size1087); + uint32_t _i1091; + for (_i1091 = 0; _i1091 < _size1087; ++_i1091) { - xfer += this->success[_i1089].read(iprot); + xfer += this->success[_i1091].read(iprot); } xfer += iprot->readListEnd(); } @@ -15371,10 +15371,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1090; - for (_iter1090 = this->success.begin(); _iter1090 != this->success.end(); ++_iter1090) + std::vector ::const_iterator _iter1092; + for (_iter1092 = this->success.begin(); _iter1092 != this->success.end(); ++_iter1092) { - xfer += (*_iter1090).write(oprot); + xfer += (*_iter1092).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15423,14 +15423,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1091; - ::apache::thrift::protocol::TType _etype1094; - xfer += iprot->readListBegin(_etype1094, _size1091); - (*(this->success)).resize(_size1091); - uint32_t _i1095; - for (_i1095 = 0; _i1095 < _size1091; ++_i1095) + uint32_t _size1093; + ::apache::thrift::protocol::TType _etype1096; + xfer += iprot->readListBegin(_etype1096, _size1093); + (*(this->success)).resize(_size1093); + uint32_t _i1097; + for (_i1097 = 0; _i1097 < _size1093; ++_i1097) { - xfer += (*(this->success))[_i1095].read(iprot); + xfer += (*(this->success))[_i1097].read(iprot); } xfer += iprot->readListEnd(); } @@ -15513,14 +15513,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - this->part_vals.resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1098; + ::apache::thrift::protocol::TType _etype1101; + xfer += iprot->readListBegin(_etype1101, _size1098); + this->part_vals.resize(_size1098); + uint32_t _i1102; + for (_i1102 = 0; _i1102 < _size1098; ++_i1102) { - xfer += iprot->readString(this->part_vals[_i1100]); + xfer += iprot->readString(this->part_vals[_i1102]); } xfer += iprot->readListEnd(); } @@ -15549,14 +15549,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1101; - ::apache::thrift::protocol::TType _etype1104; - xfer += iprot->readListBegin(_etype1104, _size1101); - this->group_names.resize(_size1101); - uint32_t _i1105; - for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + uint32_t _size1103; + ::apache::thrift::protocol::TType _etype1106; + xfer += iprot->readListBegin(_etype1106, _size1103); + this->group_names.resize(_size1103); + uint32_t _i1107; + for (_i1107 = 0; _i1107 < _size1103; ++_i1107) { - xfer += iprot->readString(this->group_names[_i1105]); + xfer += iprot->readString(this->group_names[_i1107]); } xfer += iprot->readListEnd(); } @@ -15593,10 +15593,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1106; - for (_iter1106 = this->part_vals.begin(); _iter1106 != this->part_vals.end(); ++_iter1106) + std::vector ::const_iterator _iter1108; + for (_iter1108 = this->part_vals.begin(); _iter1108 != this->part_vals.end(); ++_iter1108) { - xfer += oprot->writeString((*_iter1106)); + xfer += oprot->writeString((*_iter1108)); } xfer += oprot->writeListEnd(); } @@ -15613,10 +15613,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1107; - for (_iter1107 = this->group_names.begin(); _iter1107 != this->group_names.end(); ++_iter1107) + std::vector ::const_iterator _iter1109; + for (_iter1109 = this->group_names.begin(); _iter1109 != this->group_names.end(); ++_iter1109) { - xfer += oprot->writeString((*_iter1107)); + xfer += oprot->writeString((*_iter1109)); } xfer += oprot->writeListEnd(); } @@ -15648,10 +15648,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1108; - for (_iter1108 = (*(this->part_vals)).begin(); _iter1108 != (*(this->part_vals)).end(); ++_iter1108) + std::vector ::const_iterator _iter1110; + for (_iter1110 = (*(this->part_vals)).begin(); _iter1110 != (*(this->part_vals)).end(); ++_iter1110) { - xfer += oprot->writeString((*_iter1108)); + xfer += oprot->writeString((*_iter1110)); } xfer += oprot->writeListEnd(); } @@ -15668,10 +15668,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1109; - for (_iter1109 = (*(this->group_names)).begin(); _iter1109 != (*(this->group_names)).end(); ++_iter1109) + std::vector ::const_iterator _iter1111; + for (_iter1111 = (*(this->group_names)).begin(); _iter1111 != (*(this->group_names)).end(); ++_iter1111) { - xfer += oprot->writeString((*_iter1109)); + xfer += oprot->writeString((*_iter1111)); } xfer += oprot->writeListEnd(); } @@ -15712,14 +15712,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1110; - ::apache::thrift::protocol::TType _etype1113; - xfer += iprot->readListBegin(_etype1113, _size1110); - this->success.resize(_size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1112; + ::apache::thrift::protocol::TType _etype1115; + xfer += iprot->readListBegin(_etype1115, _size1112); + this->success.resize(_size1112); + uint32_t _i1116; + for (_i1116 = 0; _i1116 < _size1112; ++_i1116) { - xfer += this->success[_i1114].read(iprot); + xfer += this->success[_i1116].read(iprot); } xfer += iprot->readListEnd(); } @@ -15766,10 +15766,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1115; - for (_iter1115 = this->success.begin(); _iter1115 != this->success.end(); ++_iter1115) + std::vector ::const_iterator _iter1117; + for (_iter1117 = this->success.begin(); _iter1117 != this->success.end(); ++_iter1117) { - xfer += (*_iter1115).write(oprot); + xfer += (*_iter1117).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15818,14 +15818,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1116; - ::apache::thrift::protocol::TType _etype1119; - xfer += iprot->readListBegin(_etype1119, _size1116); - (*(this->success)).resize(_size1116); - uint32_t _i1120; - for (_i1120 = 0; _i1120 < _size1116; ++_i1120) + uint32_t _size1118; + ::apache::thrift::protocol::TType _etype1121; + xfer += iprot->readListBegin(_etype1121, _size1118); + (*(this->success)).resize(_size1118); + uint32_t _i1122; + for (_i1122 = 0; _i1122 < _size1118; ++_i1122) { - xfer += (*(this->success))[_i1120].read(iprot); + xfer += (*(this->success))[_i1122].read(iprot); } xfer += iprot->readListEnd(); } @@ -15908,14 +15908,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1121; - ::apache::thrift::protocol::TType _etype1124; - xfer += iprot->readListBegin(_etype1124, _size1121); - this->part_vals.resize(_size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + uint32_t _size1123; + ::apache::thrift::protocol::TType _etype1126; + xfer += iprot->readListBegin(_etype1126, _size1123); + this->part_vals.resize(_size1123); + uint32_t _i1127; + for (_i1127 = 0; _i1127 < _size1123; ++_i1127) { - xfer += iprot->readString(this->part_vals[_i1125]); + xfer += iprot->readString(this->part_vals[_i1127]); } xfer += iprot->readListEnd(); } @@ -15960,10 +15960,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1126; - for (_iter1126 = this->part_vals.begin(); _iter1126 != this->part_vals.end(); ++_iter1126) + std::vector ::const_iterator _iter1128; + for (_iter1128 = this->part_vals.begin(); _iter1128 != this->part_vals.end(); ++_iter1128) { - xfer += oprot->writeString((*_iter1126)); + xfer += oprot->writeString((*_iter1128)); } xfer += oprot->writeListEnd(); } @@ -15999,10 +15999,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1127; - for (_iter1127 = (*(this->part_vals)).begin(); _iter1127 != (*(this->part_vals)).end(); ++_iter1127) + std::vector ::const_iterator _iter1129; + for (_iter1129 = (*(this->part_vals)).begin(); _iter1129 != (*(this->part_vals)).end(); ++_iter1129) { - xfer += oprot->writeString((*_iter1127)); + xfer += oprot->writeString((*_iter1129)); } xfer += oprot->writeListEnd(); } @@ -16047,14 +16047,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1128; - ::apache::thrift::protocol::TType _etype1131; - xfer += iprot->readListBegin(_etype1131, _size1128); - this->success.resize(_size1128); - uint32_t _i1132; - for (_i1132 = 0; _i1132 < _size1128; ++_i1132) + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + this->success.resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += iprot->readString(this->success[_i1132]); + xfer += iprot->readString(this->success[_i1134]); } xfer += iprot->readListEnd(); } @@ -16101,10 +16101,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1133; - for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) + std::vector ::const_iterator _iter1135; + for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) { - xfer += oprot->writeString((*_iter1133)); + xfer += oprot->writeString((*_iter1135)); } xfer += oprot->writeListEnd(); } @@ -16153,14 +16153,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1134; - ::apache::thrift::protocol::TType _etype1137; - xfer += iprot->readListBegin(_etype1137, _size1134); - (*(this->success)).resize(_size1134); - uint32_t _i1138; - for (_i1138 = 0; _i1138 < _size1134; ++_i1138) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + (*(this->success)).resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += iprot->readString((*(this->success))[_i1138]); + xfer += iprot->readString((*(this->success))[_i1140]); } xfer += iprot->readListEnd(); } @@ -16354,14 +16354,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1139; - ::apache::thrift::protocol::TType _etype1142; - xfer += iprot->readListBegin(_etype1142, _size1139); - this->success.resize(_size1139); - uint32_t _i1143; - for (_i1143 = 0; _i1143 < _size1139; ++_i1143) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->success.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += this->success[_i1143].read(iprot); + xfer += this->success[_i1145].read(iprot); } xfer += iprot->readListEnd(); } @@ -16408,10 +16408,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1144; - for (_iter1144 = this->success.begin(); _iter1144 != this->success.end(); ++_iter1144) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->success.begin(); _iter1146 != this->success.end(); ++_iter1146) { - xfer += (*_iter1144).write(oprot); + xfer += (*_iter1146).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16460,14 +16460,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1145; - ::apache::thrift::protocol::TType _etype1148; - xfer += iprot->readListBegin(_etype1148, _size1145); - (*(this->success)).resize(_size1145); - uint32_t _i1149; - for (_i1149 = 0; _i1149 < _size1145; ++_i1149) + uint32_t _size1147; + ::apache::thrift::protocol::TType _etype1150; + xfer += iprot->readListBegin(_etype1150, _size1147); + (*(this->success)).resize(_size1147); + uint32_t _i1151; + for (_i1151 = 0; _i1151 < _size1147; ++_i1151) { - xfer += (*(this->success))[_i1149].read(iprot); + xfer += (*(this->success))[_i1151].read(iprot); } xfer += iprot->readListEnd(); } @@ -16661,14 +16661,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1150; - ::apache::thrift::protocol::TType _etype1153; - xfer += iprot->readListBegin(_etype1153, _size1150); - this->success.resize(_size1150); - uint32_t _i1154; - for (_i1154 = 0; _i1154 < _size1150; ++_i1154) + uint32_t _size1152; + ::apache::thrift::protocol::TType _etype1155; + xfer += iprot->readListBegin(_etype1155, _size1152); + this->success.resize(_size1152); + uint32_t _i1156; + for (_i1156 = 0; _i1156 < _size1152; ++_i1156) { - xfer += this->success[_i1154].read(iprot); + xfer += this->success[_i1156].read(iprot); } xfer += iprot->readListEnd(); } @@ -16715,10 +16715,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1155; - for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) + std::vector ::const_iterator _iter1157; + for (_iter1157 = this->success.begin(); _iter1157 != this->success.end(); ++_iter1157) { - xfer += (*_iter1155).write(oprot); + xfer += (*_iter1157).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16767,14 +16767,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1156; - ::apache::thrift::protocol::TType _etype1159; - xfer += iprot->readListBegin(_etype1159, _size1156); - (*(this->success)).resize(_size1156); - uint32_t _i1160; - for (_i1160 = 0; _i1160 < _size1156; ++_i1160) + uint32_t _size1158; + ::apache::thrift::protocol::TType _etype1161; + xfer += iprot->readListBegin(_etype1161, _size1158); + (*(this->success)).resize(_size1158); + uint32_t _i1162; + for (_i1162 = 0; _i1162 < _size1158; ++_i1162) { - xfer += (*(this->success))[_i1160].read(iprot); + xfer += (*(this->success))[_i1162].read(iprot); } xfer += iprot->readListEnd(); } @@ -17343,14 +17343,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1161; - ::apache::thrift::protocol::TType _etype1164; - xfer += iprot->readListBegin(_etype1164, _size1161); - this->names.resize(_size1161); - uint32_t _i1165; - for (_i1165 = 0; _i1165 < _size1161; ++_i1165) + uint32_t _size1163; + ::apache::thrift::protocol::TType _etype1166; + xfer += iprot->readListBegin(_etype1166, _size1163); + this->names.resize(_size1163); + uint32_t _i1167; + for (_i1167 = 0; _i1167 < _size1163; ++_i1167) { - xfer += iprot->readString(this->names[_i1165]); + xfer += iprot->readString(this->names[_i1167]); } xfer += iprot->readListEnd(); } @@ -17387,10 +17387,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1166; - for (_iter1166 = this->names.begin(); _iter1166 != this->names.end(); ++_iter1166) + std::vector ::const_iterator _iter1168; + for (_iter1168 = this->names.begin(); _iter1168 != this->names.end(); ++_iter1168) { - xfer += oprot->writeString((*_iter1166)); + xfer += oprot->writeString((*_iter1168)); } xfer += oprot->writeListEnd(); } @@ -17422,10 +17422,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter1167; - for (_iter1167 = (*(this->names)).begin(); _iter1167 != (*(this->names)).end(); ++_iter1167) + std::vector ::const_iterator _iter1169; + for (_iter1169 = (*(this->names)).begin(); _iter1169 != (*(this->names)).end(); ++_iter1169) { - xfer += oprot->writeString((*_iter1167)); + xfer += oprot->writeString((*_iter1169)); } xfer += oprot->writeListEnd(); } @@ -17466,14 +17466,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1168; - ::apache::thrift::protocol::TType _etype1171; - xfer += iprot->readListBegin(_etype1171, _size1168); - this->success.resize(_size1168); - uint32_t _i1172; - for (_i1172 = 0; _i1172 < _size1168; ++_i1172) + uint32_t _size1170; + ::apache::thrift::protocol::TType _etype1173; + xfer += iprot->readListBegin(_etype1173, _size1170); + this->success.resize(_size1170); + uint32_t _i1174; + for (_i1174 = 0; _i1174 < _size1170; ++_i1174) { - xfer += this->success[_i1172].read(iprot); + xfer += this->success[_i1174].read(iprot); } xfer += iprot->readListEnd(); } @@ -17520,10 +17520,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1173; - for (_iter1173 = this->success.begin(); _iter1173 != this->success.end(); ++_iter1173) + std::vector ::const_iterator _iter1175; + for (_iter1175 = this->success.begin(); _iter1175 != this->success.end(); ++_iter1175) { - xfer += (*_iter1173).write(oprot); + xfer += (*_iter1175).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17572,14 +17572,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1174; - ::apache::thrift::protocol::TType _etype1177; - xfer += iprot->readListBegin(_etype1177, _size1174); - (*(this->success)).resize(_size1174); - uint32_t _i1178; - for (_i1178 = 0; _i1178 < _size1174; ++_i1178) + uint32_t _size1176; + ::apache::thrift::protocol::TType _etype1179; + xfer += iprot->readListBegin(_etype1179, _size1176); + (*(this->success)).resize(_size1176); + uint32_t _i1180; + for (_i1180 = 0; _i1180 < _size1176; ++_i1180) { - xfer += (*(this->success))[_i1178].read(iprot); + xfer += (*(this->success))[_i1180].read(iprot); } xfer += iprot->readListEnd(); } @@ -17901,14 +17901,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1179; - ::apache::thrift::protocol::TType _etype1182; - xfer += iprot->readListBegin(_etype1182, _size1179); - this->new_parts.resize(_size1179); - uint32_t _i1183; - for (_i1183 = 0; _i1183 < _size1179; ++_i1183) + uint32_t _size1181; + ::apache::thrift::protocol::TType _etype1184; + xfer += iprot->readListBegin(_etype1184, _size1181); + this->new_parts.resize(_size1181); + uint32_t _i1185; + for (_i1185 = 0; _i1185 < _size1181; ++_i1185) { - xfer += this->new_parts[_i1183].read(iprot); + xfer += this->new_parts[_i1185].read(iprot); } xfer += iprot->readListEnd(); } @@ -17945,10 +17945,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1184; - for (_iter1184 = this->new_parts.begin(); _iter1184 != this->new_parts.end(); ++_iter1184) + std::vector ::const_iterator _iter1186; + for (_iter1186 = this->new_parts.begin(); _iter1186 != this->new_parts.end(); ++_iter1186) { - xfer += (*_iter1184).write(oprot); + xfer += (*_iter1186).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17980,10 +17980,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1185; - for (_iter1185 = (*(this->new_parts)).begin(); _iter1185 != (*(this->new_parts)).end(); ++_iter1185) + std::vector ::const_iterator _iter1187; + for (_iter1187 = (*(this->new_parts)).begin(); _iter1187 != (*(this->new_parts)).end(); ++_iter1187) { - xfer += (*_iter1185).write(oprot); + xfer += (*_iter1187).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18168,14 +18168,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1186; - ::apache::thrift::protocol::TType _etype1189; - xfer += iprot->readListBegin(_etype1189, _size1186); - this->new_parts.resize(_size1186); - uint32_t _i1190; - for (_i1190 = 0; _i1190 < _size1186; ++_i1190) + uint32_t _size1188; + ::apache::thrift::protocol::TType _etype1191; + xfer += iprot->readListBegin(_etype1191, _size1188); + this->new_parts.resize(_size1188); + uint32_t _i1192; + for (_i1192 = 0; _i1192 < _size1188; ++_i1192) { - xfer += this->new_parts[_i1190].read(iprot); + xfer += this->new_parts[_i1192].read(iprot); } xfer += iprot->readListEnd(); } @@ -18220,10 +18220,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::wri xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1191; - for (_iter1191 = this->new_parts.begin(); _iter1191 != this->new_parts.end(); ++_iter1191) + std::vector ::const_iterator _iter1193; + for (_iter1193 = this->new_parts.begin(); _iter1193 != this->new_parts.end(); ++_iter1193) { - xfer += (*_iter1191).write(oprot); + xfer += (*_iter1193).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18259,10 +18259,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1192; - for (_iter1192 = (*(this->new_parts)).begin(); _iter1192 != (*(this->new_parts)).end(); ++_iter1192) + std::vector ::const_iterator _iter1194; + for (_iter1194 = (*(this->new_parts)).begin(); _iter1194 != (*(this->new_parts)).end(); ++_iter1194) { - xfer += (*_iter1192).write(oprot); + xfer += (*_iter1194).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18706,14 +18706,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1193; - ::apache::thrift::protocol::TType _etype1196; - xfer += iprot->readListBegin(_etype1196, _size1193); - this->part_vals.resize(_size1193); - uint32_t _i1197; - for (_i1197 = 0; _i1197 < _size1193; ++_i1197) + uint32_t _size1195; + ::apache::thrift::protocol::TType _etype1198; + xfer += iprot->readListBegin(_etype1198, _size1195); + this->part_vals.resize(_size1195); + uint32_t _i1199; + for (_i1199 = 0; _i1199 < _size1195; ++_i1199) { - xfer += iprot->readString(this->part_vals[_i1197]); + xfer += iprot->readString(this->part_vals[_i1199]); } xfer += iprot->readListEnd(); } @@ -18758,10 +18758,10 @@ uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1198; - for (_iter1198 = this->part_vals.begin(); _iter1198 != this->part_vals.end(); ++_iter1198) + std::vector ::const_iterator _iter1200; + for (_iter1200 = this->part_vals.begin(); _iter1200 != this->part_vals.end(); ++_iter1200) { - xfer += oprot->writeString((*_iter1198)); + xfer += oprot->writeString((*_iter1200)); } xfer += oprot->writeListEnd(); } @@ -18797,10 +18797,10 @@ uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1199; - for (_iter1199 = (*(this->part_vals)).begin(); _iter1199 != (*(this->part_vals)).end(); ++_iter1199) + std::vector ::const_iterator _iter1201; + for (_iter1201 = (*(this->part_vals)).begin(); _iter1201 != (*(this->part_vals)).end(); ++_iter1201) { - xfer += oprot->writeString((*_iter1199)); + xfer += oprot->writeString((*_iter1201)); } xfer += oprot->writeListEnd(); } @@ -18973,14 +18973,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1200; - ::apache::thrift::protocol::TType _etype1203; - xfer += iprot->readListBegin(_etype1203, _size1200); - this->part_vals.resize(_size1200); - uint32_t _i1204; - for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + uint32_t _size1202; + ::apache::thrift::protocol::TType _etype1205; + xfer += iprot->readListBegin(_etype1205, _size1202); + this->part_vals.resize(_size1202); + uint32_t _i1206; + for (_i1206 = 0; _i1206 < _size1202; ++_i1206) { - xfer += iprot->readString(this->part_vals[_i1204]); + xfer += iprot->readString(this->part_vals[_i1206]); } xfer += iprot->readListEnd(); } @@ -19017,10 +19017,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1205; - for (_iter1205 = this->part_vals.begin(); _iter1205 != this->part_vals.end(); ++_iter1205) + std::vector ::const_iterator _iter1207; + for (_iter1207 = this->part_vals.begin(); _iter1207 != this->part_vals.end(); ++_iter1207) { - xfer += oprot->writeString((*_iter1205)); + xfer += oprot->writeString((*_iter1207)); } xfer += oprot->writeListEnd(); } @@ -19048,10 +19048,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1206; - for (_iter1206 = (*(this->part_vals)).begin(); _iter1206 != (*(this->part_vals)).end(); ++_iter1206) + std::vector ::const_iterator _iter1208; + for (_iter1208 = (*(this->part_vals)).begin(); _iter1208 != (*(this->part_vals)).end(); ++_iter1208) { - xfer += oprot->writeString((*_iter1206)); + xfer += oprot->writeString((*_iter1208)); } xfer += oprot->writeListEnd(); } @@ -19526,14 +19526,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1207; - ::apache::thrift::protocol::TType _etype1210; - xfer += iprot->readListBegin(_etype1210, _size1207); - this->success.resize(_size1207); - uint32_t _i1211; - for (_i1211 = 0; _i1211 < _size1207; ++_i1211) + uint32_t _size1209; + ::apache::thrift::protocol::TType _etype1212; + xfer += iprot->readListBegin(_etype1212, _size1209); + this->success.resize(_size1209); + uint32_t _i1213; + for (_i1213 = 0; _i1213 < _size1209; ++_i1213) { - xfer += iprot->readString(this->success[_i1211]); + xfer += iprot->readString(this->success[_i1213]); } xfer += iprot->readListEnd(); } @@ -19572,10 +19572,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1212; - for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212) + std::vector ::const_iterator _iter1214; + for (_iter1214 = this->success.begin(); _iter1214 != this->success.end(); ++_iter1214) { - xfer += oprot->writeString((*_iter1212)); + xfer += oprot->writeString((*_iter1214)); } xfer += oprot->writeListEnd(); } @@ -19620,14 +19620,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1213; - ::apache::thrift::protocol::TType _etype1216; - xfer += iprot->readListBegin(_etype1216, _size1213); - (*(this->success)).resize(_size1213); - uint32_t _i1217; - for (_i1217 = 0; _i1217 < _size1213; ++_i1217) + uint32_t _size1215; + ::apache::thrift::protocol::TType _etype1218; + xfer += iprot->readListBegin(_etype1218, _size1215); + (*(this->success)).resize(_size1215); + uint32_t _i1219; + for (_i1219 = 0; _i1219 < _size1215; ++_i1219) { - xfer += iprot->readString((*(this->success))[_i1217]); + xfer += iprot->readString((*(this->success))[_i1219]); } xfer += iprot->readListEnd(); } @@ -19765,17 +19765,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1218; - ::apache::thrift::protocol::TType _ktype1219; - ::apache::thrift::protocol::TType _vtype1220; - xfer += iprot->readMapBegin(_ktype1219, _vtype1220, _size1218); - uint32_t _i1222; - for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + uint32_t _size1220; + ::apache::thrift::protocol::TType _ktype1221; + ::apache::thrift::protocol::TType _vtype1222; + xfer += iprot->readMapBegin(_ktype1221, _vtype1222, _size1220); + uint32_t _i1224; + for (_i1224 = 0; _i1224 < _size1220; ++_i1224) { - std::string _key1223; - xfer += iprot->readString(_key1223); - std::string& _val1224 = this->success[_key1223]; - xfer += iprot->readString(_val1224); + std::string _key1225; + xfer += iprot->readString(_key1225); + std::string& _val1226 = this->success[_key1225]; + xfer += iprot->readString(_val1226); } xfer += iprot->readMapEnd(); } @@ -19814,11 +19814,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter1225; - for (_iter1225 = this->success.begin(); _iter1225 != this->success.end(); ++_iter1225) + std::map ::const_iterator _iter1227; + for (_iter1227 = this->success.begin(); _iter1227 != this->success.end(); ++_iter1227) { - xfer += oprot->writeString(_iter1225->first); - xfer += oprot->writeString(_iter1225->second); + xfer += oprot->writeString(_iter1227->first); + xfer += oprot->writeString(_iter1227->second); } xfer += oprot->writeMapEnd(); } @@ -19863,17 +19863,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1226; - ::apache::thrift::protocol::TType _ktype1227; - ::apache::thrift::protocol::TType _vtype1228; - xfer += iprot->readMapBegin(_ktype1227, _vtype1228, _size1226); - uint32_t _i1230; - for (_i1230 = 0; _i1230 < _size1226; ++_i1230) + uint32_t _size1228; + ::apache::thrift::protocol::TType _ktype1229; + ::apache::thrift::protocol::TType _vtype1230; + xfer += iprot->readMapBegin(_ktype1229, _vtype1230, _size1228); + uint32_t _i1232; + for (_i1232 = 0; _i1232 < _size1228; ++_i1232) { - std::string _key1231; - xfer += iprot->readString(_key1231); - std::string& _val1232 = (*(this->success))[_key1231]; - xfer += iprot->readString(_val1232); + std::string _key1233; + xfer += iprot->readString(_key1233); + std::string& _val1234 = (*(this->success))[_key1233]; + xfer += iprot->readString(_val1234); } xfer += iprot->readMapEnd(); } @@ -19948,17 +19948,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1233; - ::apache::thrift::protocol::TType _ktype1234; - ::apache::thrift::protocol::TType _vtype1235; - xfer += iprot->readMapBegin(_ktype1234, _vtype1235, _size1233); - uint32_t _i1237; - for (_i1237 = 0; _i1237 < _size1233; ++_i1237) + uint32_t _size1235; + ::apache::thrift::protocol::TType _ktype1236; + ::apache::thrift::protocol::TType _vtype1237; + xfer += iprot->readMapBegin(_ktype1236, _vtype1237, _size1235); + uint32_t _i1239; + for (_i1239 = 0; _i1239 < _size1235; ++_i1239) { - std::string _key1238; - xfer += iprot->readString(_key1238); - std::string& _val1239 = this->part_vals[_key1238]; - xfer += iprot->readString(_val1239); + std::string _key1240; + xfer += iprot->readString(_key1240); + std::string& _val1241 = this->part_vals[_key1240]; + xfer += iprot->readString(_val1241); } xfer += iprot->readMapEnd(); } @@ -19969,9 +19969,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1240; - xfer += iprot->readI32(ecast1240); - this->eventType = (PartitionEventType::type)ecast1240; + int32_t ecast1242; + xfer += iprot->readI32(ecast1242); + this->eventType = (PartitionEventType::type)ecast1242; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20005,11 +20005,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1241; - for (_iter1241 = this->part_vals.begin(); _iter1241 != this->part_vals.end(); ++_iter1241) + std::map ::const_iterator _iter1243; + for (_iter1243 = this->part_vals.begin(); _iter1243 != this->part_vals.end(); ++_iter1243) { - xfer += oprot->writeString(_iter1241->first); - xfer += oprot->writeString(_iter1241->second); + xfer += oprot->writeString(_iter1243->first); + xfer += oprot->writeString(_iter1243->second); } xfer += oprot->writeMapEnd(); } @@ -20045,11 +20045,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1242; - for (_iter1242 = (*(this->part_vals)).begin(); _iter1242 != (*(this->part_vals)).end(); ++_iter1242) + std::map ::const_iterator _iter1244; + for (_iter1244 = (*(this->part_vals)).begin(); _iter1244 != (*(this->part_vals)).end(); ++_iter1244) { - xfer += oprot->writeString(_iter1242->first); - xfer += oprot->writeString(_iter1242->second); + xfer += oprot->writeString(_iter1244->first); + xfer += oprot->writeString(_iter1244->second); } xfer += oprot->writeMapEnd(); } @@ -20318,17 +20318,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1243; - ::apache::thrift::protocol::TType _ktype1244; - ::apache::thrift::protocol::TType _vtype1245; - xfer += iprot->readMapBegin(_ktype1244, _vtype1245, _size1243); - uint32_t _i1247; - for (_i1247 = 0; _i1247 < _size1243; ++_i1247) + uint32_t _size1245; + ::apache::thrift::protocol::TType _ktype1246; + ::apache::thrift::protocol::TType _vtype1247; + xfer += iprot->readMapBegin(_ktype1246, _vtype1247, _size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - std::string _key1248; - xfer += iprot->readString(_key1248); - std::string& _val1249 = this->part_vals[_key1248]; - xfer += iprot->readString(_val1249); + std::string _key1250; + xfer += iprot->readString(_key1250); + std::string& _val1251 = this->part_vals[_key1250]; + xfer += iprot->readString(_val1251); } xfer += iprot->readMapEnd(); } @@ -20339,9 +20339,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1250; - xfer += iprot->readI32(ecast1250); - this->eventType = (PartitionEventType::type)ecast1250; + int32_t ecast1252; + xfer += iprot->readI32(ecast1252); + this->eventType = (PartitionEventType::type)ecast1252; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20375,11 +20375,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1251; - for (_iter1251 = this->part_vals.begin(); _iter1251 != this->part_vals.end(); ++_iter1251) + std::map ::const_iterator _iter1253; + for (_iter1253 = this->part_vals.begin(); _iter1253 != this->part_vals.end(); ++_iter1253) { - xfer += oprot->writeString(_iter1251->first); - xfer += oprot->writeString(_iter1251->second); + xfer += oprot->writeString(_iter1253->first); + xfer += oprot->writeString(_iter1253->second); } xfer += oprot->writeMapEnd(); } @@ -20415,11 +20415,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1252; - for (_iter1252 = (*(this->part_vals)).begin(); _iter1252 != (*(this->part_vals)).end(); ++_iter1252) + std::map ::const_iterator _iter1254; + for (_iter1254 = (*(this->part_vals)).begin(); _iter1254 != (*(this->part_vals)).end(); ++_iter1254) { - xfer += oprot->writeString(_iter1252->first); - xfer += oprot->writeString(_iter1252->second); + xfer += oprot->writeString(_iter1254->first); + xfer += oprot->writeString(_iter1254->second); } xfer += oprot->writeMapEnd(); } @@ -21855,14 +21855,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1253; - ::apache::thrift::protocol::TType _etype1256; - xfer += iprot->readListBegin(_etype1256, _size1253); - this->success.resize(_size1253); - uint32_t _i1257; - for (_i1257 = 0; _i1257 < _size1253; ++_i1257) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->success.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += this->success[_i1257].read(iprot); + xfer += this->success[_i1259].read(iprot); } xfer += iprot->readListEnd(); } @@ -21909,10 +21909,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1258; - for (_iter1258 = this->success.begin(); _iter1258 != this->success.end(); ++_iter1258) + std::vector ::const_iterator _iter1260; + for (_iter1260 = this->success.begin(); _iter1260 != this->success.end(); ++_iter1260) { - xfer += (*_iter1258).write(oprot); + xfer += (*_iter1260).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21961,14 +21961,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1259; - ::apache::thrift::protocol::TType _etype1262; - xfer += iprot->readListBegin(_etype1262, _size1259); - (*(this->success)).resize(_size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + (*(this->success)).resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += (*(this->success))[_i1263].read(iprot); + xfer += (*(this->success))[_i1265].read(iprot); } xfer += iprot->readListEnd(); } @@ -22146,14 +22146,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1264; - ::apache::thrift::protocol::TType _etype1267; - xfer += iprot->readListBegin(_etype1267, _size1264); - this->success.resize(_size1264); - uint32_t _i1268; - for (_i1268 = 0; _i1268 < _size1264; ++_i1268) + uint32_t _size1266; + ::apache::thrift::protocol::TType _etype1269; + xfer += iprot->readListBegin(_etype1269, _size1266); + this->success.resize(_size1266); + uint32_t _i1270; + for (_i1270 = 0; _i1270 < _size1266; ++_i1270) { - xfer += iprot->readString(this->success[_i1268]); + xfer += iprot->readString(this->success[_i1270]); } xfer += iprot->readListEnd(); } @@ -22192,10 +22192,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1269; - for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) + std::vector ::const_iterator _iter1271; + for (_iter1271 = this->success.begin(); _iter1271 != this->success.end(); ++_iter1271) { - xfer += oprot->writeString((*_iter1269)); + xfer += oprot->writeString((*_iter1271)); } xfer += oprot->writeListEnd(); } @@ -22240,14 +22240,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1270; - ::apache::thrift::protocol::TType _etype1273; - xfer += iprot->readListBegin(_etype1273, _size1270); - (*(this->success)).resize(_size1270); - uint32_t _i1274; - for (_i1274 = 0; _i1274 < _size1270; ++_i1274) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + (*(this->success)).resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += iprot->readString((*(this->success))[_i1274]); + xfer += iprot->readString((*(this->success))[_i1276]); } xfer += iprot->readListEnd(); } @@ -26274,14 +26274,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1275; - ::apache::thrift::protocol::TType _etype1278; - xfer += iprot->readListBegin(_etype1278, _size1275); - this->success.resize(_size1275); - uint32_t _i1279; - for (_i1279 = 0; _i1279 < _size1275; ++_i1279) + uint32_t _size1277; + ::apache::thrift::protocol::TType _etype1280; + xfer += iprot->readListBegin(_etype1280, _size1277); + this->success.resize(_size1277); + uint32_t _i1281; + for (_i1281 = 0; _i1281 < _size1277; ++_i1281) { - xfer += iprot->readString(this->success[_i1279]); + xfer += iprot->readString(this->success[_i1281]); } xfer += iprot->readListEnd(); } @@ -26320,10 +26320,10 @@ uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1280; - for (_iter1280 = this->success.begin(); _iter1280 != this->success.end(); ++_iter1280) + std::vector ::const_iterator _iter1282; + for (_iter1282 = this->success.begin(); _iter1282 != this->success.end(); ++_iter1282) { - xfer += oprot->writeString((*_iter1280)); + xfer += oprot->writeString((*_iter1282)); } xfer += oprot->writeListEnd(); } @@ -26368,14 +26368,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1281; - ::apache::thrift::protocol::TType _etype1284; - xfer += iprot->readListBegin(_etype1284, _size1281); - (*(this->success)).resize(_size1281); - uint32_t _i1285; - for (_i1285 = 0; _i1285 < _size1281; ++_i1285) + uint32_t _size1283; + ::apache::thrift::protocol::TType _etype1286; + xfer += iprot->readListBegin(_etype1286, _size1283); + (*(this->success)).resize(_size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - xfer += iprot->readString((*(this->success))[_i1285]); + xfer += iprot->readString((*(this->success))[_i1287]); } xfer += iprot->readListEnd(); } @@ -27335,14 +27335,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1286; - ::apache::thrift::protocol::TType _etype1289; - xfer += iprot->readListBegin(_etype1289, _size1286); - this->success.resize(_size1286); - uint32_t _i1290; - for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + uint32_t _size1288; + ::apache::thrift::protocol::TType _etype1291; + xfer += iprot->readListBegin(_etype1291, _size1288); + this->success.resize(_size1288); + uint32_t _i1292; + for (_i1292 = 0; _i1292 < _size1288; ++_i1292) { - xfer += iprot->readString(this->success[_i1290]); + xfer += iprot->readString(this->success[_i1292]); } xfer += iprot->readListEnd(); } @@ -27381,10 +27381,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1291; - for (_iter1291 = this->success.begin(); _iter1291 != this->success.end(); ++_iter1291) + std::vector ::const_iterator _iter1293; + for (_iter1293 = this->success.begin(); _iter1293 != this->success.end(); ++_iter1293) { - xfer += oprot->writeString((*_iter1291)); + xfer += oprot->writeString((*_iter1293)); } xfer += oprot->writeListEnd(); } @@ -27429,14 +27429,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - (*(this->success)).resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + uint32_t _size1294; + ::apache::thrift::protocol::TType _etype1297; + xfer += iprot->readListBegin(_etype1297, _size1294); + (*(this->success)).resize(_size1294); + uint32_t _i1298; + for (_i1298 = 0; _i1298 < _size1294; ++_i1298) { - xfer += iprot->readString((*(this->success))[_i1296]); + xfer += iprot->readString((*(this->success))[_i1298]); } xfer += iprot->readListEnd(); } @@ -27509,9 +27509,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1297; - xfer += iprot->readI32(ecast1297); - this->principal_type = (PrincipalType::type)ecast1297; + int32_t ecast1299; + xfer += iprot->readI32(ecast1299); + this->principal_type = (PrincipalType::type)ecast1299; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -27527,9 +27527,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1298; - xfer += iprot->readI32(ecast1298); - this->grantorType = (PrincipalType::type)ecast1298; + int32_t ecast1300; + xfer += iprot->readI32(ecast1300); + this->grantorType = (PrincipalType::type)ecast1300; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -27800,9 +27800,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1299; - xfer += iprot->readI32(ecast1299); - this->principal_type = (PrincipalType::type)ecast1299; + int32_t ecast1301; + xfer += iprot->readI32(ecast1301); + this->principal_type = (PrincipalType::type)ecast1301; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28033,9 +28033,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1300; - xfer += iprot->readI32(ecast1300); - this->principal_type = (PrincipalType::type)ecast1300; + int32_t ecast1302; + xfer += iprot->readI32(ecast1302); + this->principal_type = (PrincipalType::type)ecast1302; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28124,14 +28124,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1301; - ::apache::thrift::protocol::TType _etype1304; - xfer += iprot->readListBegin(_etype1304, _size1301); - this->success.resize(_size1301); - uint32_t _i1305; - for (_i1305 = 0; _i1305 < _size1301; ++_i1305) + uint32_t _size1303; + ::apache::thrift::protocol::TType _etype1306; + xfer += iprot->readListBegin(_etype1306, _size1303); + this->success.resize(_size1303); + uint32_t _i1307; + for (_i1307 = 0; _i1307 < _size1303; ++_i1307) { - xfer += this->success[_i1305].read(iprot); + xfer += this->success[_i1307].read(iprot); } xfer += iprot->readListEnd(); } @@ -28170,10 +28170,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1306; - for (_iter1306 = this->success.begin(); _iter1306 != this->success.end(); ++_iter1306) + std::vector ::const_iterator _iter1308; + for (_iter1308 = this->success.begin(); _iter1308 != this->success.end(); ++_iter1308) { - xfer += (*_iter1306).write(oprot); + xfer += (*_iter1308).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28218,14 +28218,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1307; - ::apache::thrift::protocol::TType _etype1310; - xfer += iprot->readListBegin(_etype1310, _size1307); - (*(this->success)).resize(_size1307); - uint32_t _i1311; - for (_i1311 = 0; _i1311 < _size1307; ++_i1311) + uint32_t _size1309; + ::apache::thrift::protocol::TType _etype1312; + xfer += iprot->readListBegin(_etype1312, _size1309); + (*(this->success)).resize(_size1309); + uint32_t _i1313; + for (_i1313 = 0; _i1313 < _size1309; ++_i1313) { - xfer += (*(this->success))[_i1311].read(iprot); + xfer += (*(this->success))[_i1313].read(iprot); } xfer += iprot->readListEnd(); } @@ -28921,14 +28921,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1312; - ::apache::thrift::protocol::TType _etype1315; - xfer += iprot->readListBegin(_etype1315, _size1312); - this->group_names.resize(_size1312); - uint32_t _i1316; - for (_i1316 = 0; _i1316 < _size1312; ++_i1316) + uint32_t _size1314; + ::apache::thrift::protocol::TType _etype1317; + xfer += iprot->readListBegin(_etype1317, _size1314); + this->group_names.resize(_size1314); + uint32_t _i1318; + for (_i1318 = 0; _i1318 < _size1314; ++_i1318) { - xfer += iprot->readString(this->group_names[_i1316]); + xfer += iprot->readString(this->group_names[_i1318]); } xfer += iprot->readListEnd(); } @@ -28965,10 +28965,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1317; - for (_iter1317 = this->group_names.begin(); _iter1317 != this->group_names.end(); ++_iter1317) + std::vector ::const_iterator _iter1319; + for (_iter1319 = this->group_names.begin(); _iter1319 != this->group_names.end(); ++_iter1319) { - xfer += oprot->writeString((*_iter1317)); + xfer += oprot->writeString((*_iter1319)); } xfer += oprot->writeListEnd(); } @@ -29000,10 +29000,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1318; - for (_iter1318 = (*(this->group_names)).begin(); _iter1318 != (*(this->group_names)).end(); ++_iter1318) + std::vector ::const_iterator _iter1320; + for (_iter1320 = (*(this->group_names)).begin(); _iter1320 != (*(this->group_names)).end(); ++_iter1320) { - xfer += oprot->writeString((*_iter1318)); + xfer += oprot->writeString((*_iter1320)); } xfer += oprot->writeListEnd(); } @@ -29178,9 +29178,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1319; - xfer += iprot->readI32(ecast1319); - this->principal_type = (PrincipalType::type)ecast1319; + int32_t ecast1321; + xfer += iprot->readI32(ecast1321); + this->principal_type = (PrincipalType::type)ecast1321; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29285,14 +29285,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1320; - ::apache::thrift::protocol::TType _etype1323; - xfer += iprot->readListBegin(_etype1323, _size1320); - this->success.resize(_size1320); - uint32_t _i1324; - for (_i1324 = 0; _i1324 < _size1320; ++_i1324) + uint32_t _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->success.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += this->success[_i1324].read(iprot); + xfer += this->success[_i1326].read(iprot); } xfer += iprot->readListEnd(); } @@ -29331,10 +29331,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1325; - for (_iter1325 = this->success.begin(); _iter1325 != this->success.end(); ++_iter1325) + std::vector ::const_iterator _iter1327; + for (_iter1327 = this->success.begin(); _iter1327 != this->success.end(); ++_iter1327) { - xfer += (*_iter1325).write(oprot); + xfer += (*_iter1327).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29379,14 +29379,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1326; - ::apache::thrift::protocol::TType _etype1329; - xfer += iprot->readListBegin(_etype1329, _size1326); - (*(this->success)).resize(_size1326); - uint32_t _i1330; - for (_i1330 = 0; _i1330 < _size1326; ++_i1330) + uint32_t _size1328; + ::apache::thrift::protocol::TType _etype1331; + xfer += iprot->readListBegin(_etype1331, _size1328); + (*(this->success)).resize(_size1328); + uint32_t _i1332; + for (_i1332 = 0; _i1332 < _size1328; ++_i1332) { - xfer += (*(this->success))[_i1330].read(iprot); + xfer += (*(this->success))[_i1332].read(iprot); } xfer += iprot->readListEnd(); } @@ -30074,14 +30074,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1331; - ::apache::thrift::protocol::TType _etype1334; - xfer += iprot->readListBegin(_etype1334, _size1331); - this->group_names.resize(_size1331); - uint32_t _i1335; - for (_i1335 = 0; _i1335 < _size1331; ++_i1335) + uint32_t _size1333; + ::apache::thrift::protocol::TType _etype1336; + xfer += iprot->readListBegin(_etype1336, _size1333); + this->group_names.resize(_size1333); + uint32_t _i1337; + for (_i1337 = 0; _i1337 < _size1333; ++_i1337) { - xfer += iprot->readString(this->group_names[_i1335]); + xfer += iprot->readString(this->group_names[_i1337]); } xfer += iprot->readListEnd(); } @@ -30114,10 +30114,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1336; - for (_iter1336 = this->group_names.begin(); _iter1336 != this->group_names.end(); ++_iter1336) + std::vector ::const_iterator _iter1338; + for (_iter1338 = this->group_names.begin(); _iter1338 != this->group_names.end(); ++_iter1338) { - xfer += oprot->writeString((*_iter1336)); + xfer += oprot->writeString((*_iter1338)); } xfer += oprot->writeListEnd(); } @@ -30145,10 +30145,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1337; - for (_iter1337 = (*(this->group_names)).begin(); _iter1337 != (*(this->group_names)).end(); ++_iter1337) + std::vector ::const_iterator _iter1339; + for (_iter1339 = (*(this->group_names)).begin(); _iter1339 != (*(this->group_names)).end(); ++_iter1339) { - xfer += oprot->writeString((*_iter1337)); + xfer += oprot->writeString((*_iter1339)); } xfer += oprot->writeListEnd(); } @@ -30189,14 +30189,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1338; - ::apache::thrift::protocol::TType _etype1341; - xfer += iprot->readListBegin(_etype1341, _size1338); - this->success.resize(_size1338); - uint32_t _i1342; - for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + uint32_t _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->success.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->success[_i1342]); + xfer += iprot->readString(this->success[_i1344]); } xfer += iprot->readListEnd(); } @@ -30235,10 +30235,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1343; - for (_iter1343 = this->success.begin(); _iter1343 != this->success.end(); ++_iter1343) + std::vector ::const_iterator _iter1345; + for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1343)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -30283,14 +30283,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1344; - ::apache::thrift::protocol::TType _etype1347; - xfer += iprot->readListBegin(_etype1347, _size1344); - (*(this->success)).resize(_size1344); - uint32_t _i1348; - for (_i1348 = 0; _i1348 < _size1344; ++_i1348) + uint32_t _size1346; + ::apache::thrift::protocol::TType _etype1349; + xfer += iprot->readListBegin(_etype1349, _size1346); + (*(this->success)).resize(_size1346); + uint32_t _i1350; + for (_i1350 = 0; _i1350 < _size1346; ++_i1350) { - xfer += iprot->readString((*(this->success))[_i1348]); + xfer += iprot->readString((*(this->success))[_i1350]); } xfer += iprot->readListEnd(); } @@ -31601,14 +31601,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1349; - ::apache::thrift::protocol::TType _etype1352; - xfer += iprot->readListBegin(_etype1352, _size1349); - this->success.resize(_size1349); - uint32_t _i1353; - for (_i1353 = 0; _i1353 < _size1349; ++_i1353) + uint32_t _size1351; + ::apache::thrift::protocol::TType _etype1354; + xfer += iprot->readListBegin(_etype1354, _size1351); + this->success.resize(_size1351); + uint32_t _i1355; + for (_i1355 = 0; _i1355 < _size1351; ++_i1355) { - xfer += iprot->readString(this->success[_i1353]); + xfer += iprot->readString(this->success[_i1355]); } xfer += iprot->readListEnd(); } @@ -31639,10 +31639,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1354; - for (_iter1354 = this->success.begin(); _iter1354 != this->success.end(); ++_iter1354) + std::vector ::const_iterator _iter1356; + for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1354)); + xfer += oprot->writeString((*_iter1356)); } xfer += oprot->writeListEnd(); } @@ -31683,14 +31683,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1355; - ::apache::thrift::protocol::TType _etype1358; - xfer += iprot->readListBegin(_etype1358, _size1355); - (*(this->success)).resize(_size1355); - uint32_t _i1359; - for (_i1359 = 0; _i1359 < _size1355; ++_i1359) + uint32_t _size1357; + ::apache::thrift::protocol::TType _etype1360; + xfer += iprot->readListBegin(_etype1360, _size1357); + (*(this->success)).resize(_size1357); + uint32_t _i1361; + for (_i1361 = 0; _i1361 < _size1357; ++_i1361) { - xfer += iprot->readString((*(this->success))[_i1359]); + xfer += iprot->readString((*(this->success))[_i1361]); } xfer += iprot->readListEnd(); } @@ -32416,14 +32416,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1360; - ::apache::thrift::protocol::TType _etype1363; - xfer += iprot->readListBegin(_etype1363, _size1360); - this->success.resize(_size1360); - uint32_t _i1364; - for (_i1364 = 0; _i1364 < _size1360; ++_i1364) + uint32_t _size1362; + ::apache::thrift::protocol::TType _etype1365; + xfer += iprot->readListBegin(_etype1365, _size1362); + this->success.resize(_size1362); + uint32_t _i1366; + for (_i1366 = 0; _i1366 < _size1362; ++_i1366) { - xfer += iprot->readString(this->success[_i1364]); + xfer += iprot->readString(this->success[_i1366]); } xfer += iprot->readListEnd(); } @@ -32454,10 +32454,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1365; - for (_iter1365 = this->success.begin(); _iter1365 != this->success.end(); ++_iter1365) + std::vector ::const_iterator _iter1367; + for (_iter1367 = this->success.begin(); _iter1367 != this->success.end(); ++_iter1367) { - xfer += oprot->writeString((*_iter1365)); + xfer += oprot->writeString((*_iter1367)); } xfer += oprot->writeListEnd(); } @@ -32498,14 +32498,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1366; - ::apache::thrift::protocol::TType _etype1369; - xfer += iprot->readListBegin(_etype1369, _size1366); - (*(this->success)).resize(_size1366); - uint32_t _i1370; - for (_i1370 = 0; _i1370 < _size1366; ++_i1370) + uint32_t _size1368; + ::apache::thrift::protocol::TType _etype1371; + xfer += iprot->readListBegin(_etype1371, _size1368); + (*(this->success)).resize(_size1368); + uint32_t _i1372; + for (_i1372 = 0; _i1372 < _size1368; ++_i1372) { - xfer += iprot->readString((*(this->success))[_i1370]); + xfer += iprot->readString((*(this->success))[_i1372]); } xfer += iprot->readListEnd(); } diff --git metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index cd8c552..f8ca7cd 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -119,6 +119,24 @@ const char* _kGrantRevokeTypeNames[] = { }; const std::map _GrantRevokeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kGrantRevokeTypeValues, _kGrantRevokeTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +int _kDataOperationTypeValues[] = { + DataOperationType::SELECT, + DataOperationType::INSERT, + DataOperationType::UPDATE, + DataOperationType::DELETE, + DataOperationType::UNSET, + DataOperationType::NO_TXN +}; +const char* _kDataOperationTypeNames[] = { + "SELECT", + "INSERT", + "UPDATE", + "DELETE", + "UNSET", + "NO_TXN" +}; +const std::map _DataOperationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kDataOperationTypeValues, _kDataOperationTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + int _kEventRequestTypeValues[] = { EventRequestType::INSERT, EventRequestType::UPDATE, @@ -12578,6 +12596,16 @@ void LockComponent::__set_partitionname(const std::string& val) { __isset.partitionname = true; } +void LockComponent::__set_operationType(const DataOperationType::type val) { + this->operationType = val; +__isset.operationType = true; +} + +void LockComponent::__set_isAcid(const bool val) { + this->isAcid = val; +__isset.isAcid = true; +} + uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -12646,6 +12674,24 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast550; + xfer += iprot->readI32(ecast550); + this->operationType = (DataOperationType::type)ecast550; + this->__isset.operationType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isAcid); + this->__isset.isAcid = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -12691,6 +12737,16 @@ uint32_t LockComponent::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeString(this->partitionname); xfer += oprot->writeFieldEnd(); } + if (this->__isset.operationType) { + xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32((int32_t)this->operationType); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isAcid) { + xfer += oprot->writeFieldBegin("isAcid", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->isAcid); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -12703,24 +12759,30 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.dbname, b.dbname); swap(a.tablename, b.tablename); swap(a.partitionname, b.partitionname); + swap(a.operationType, b.operationType); + swap(a.isAcid, b.isAcid); swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other550) { - type = other550.type; - level = other550.level; - dbname = other550.dbname; - tablename = other550.tablename; - partitionname = other550.partitionname; - __isset = other550.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other551) { +LockComponent::LockComponent(const LockComponent& other551) { type = other551.type; level = other551.level; dbname = other551.dbname; tablename = other551.tablename; partitionname = other551.partitionname; + operationType = other551.operationType; + isAcid = other551.isAcid; __isset = other551.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other552) { + type = other552.type; + level = other552.level; + dbname = other552.dbname; + tablename = other552.tablename; + partitionname = other552.partitionname; + operationType = other552.operationType; + isAcid = other552.isAcid; + __isset = other552.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12731,6 +12793,8 @@ void LockComponent::printTo(std::ostream& out) const { out << ", " << "dbname=" << to_string(dbname); out << ", " << "tablename="; (__isset.tablename ? (out << to_string(tablename)) : (out << "")); out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "operationType="; (__isset.operationType ? (out << to_string(operationType)) : (out << "")); + out << ", " << "isAcid="; (__isset.isAcid ? (out << to_string(isAcid)) : (out << "")); out << ")"; } @@ -12789,14 +12853,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size552; - ::apache::thrift::protocol::TType _etype555; - xfer += iprot->readListBegin(_etype555, _size552); - this->component.resize(_size552); - uint32_t _i556; - for (_i556 = 0; _i556 < _size552; ++_i556) + uint32_t _size553; + ::apache::thrift::protocol::TType _etype556; + xfer += iprot->readListBegin(_etype556, _size553); + this->component.resize(_size553); + uint32_t _i557; + for (_i557 = 0; _i557 < _size553; ++_i557) { - xfer += this->component[_i556].read(iprot); + xfer += this->component[_i557].read(iprot); } xfer += iprot->readListEnd(); } @@ -12863,10 +12927,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); - std::vector ::const_iterator _iter557; - for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557) + std::vector ::const_iterator _iter558; + for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558) { - xfer += (*_iter557).write(oprot); + xfer += (*_iter558).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12905,21 +12969,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other558) { - component = other558.component; - txnid = other558.txnid; - user = other558.user; - hostname = other558.hostname; - agentInfo = other558.agentInfo; - __isset = other558.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other559) { +LockRequest::LockRequest(const LockRequest& other559) { component = other559.component; txnid = other559.txnid; user = other559.user; hostname = other559.hostname; agentInfo = other559.agentInfo; __isset = other559.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other560) { + component = other560.component; + txnid = other560.txnid; + user = other560.user; + hostname = other560.hostname; + agentInfo = other560.agentInfo; + __isset = other560.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -12979,9 +13043,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast560; - xfer += iprot->readI32(ecast560); - this->state = (LockState::type)ecast560; + int32_t ecast561; + xfer += iprot->readI32(ecast561); + this->state = (LockState::type)ecast561; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13027,13 +13091,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other561) { - lockid = other561.lockid; - state = other561.state; -} -LockResponse& LockResponse::operator=(const LockResponse& other562) { +LockResponse::LockResponse(const LockResponse& other562) { lockid = other562.lockid; state = other562.state; +} +LockResponse& LockResponse::operator=(const LockResponse& other563) { + lockid = other563.lockid; + state = other563.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -13155,17 +13219,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other563) { - lockid = other563.lockid; - txnid = other563.txnid; - elapsed_ms = other563.elapsed_ms; - __isset = other563.__isset; -} -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other564) { +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other564) { lockid = other564.lockid; txnid = other564.txnid; elapsed_ms = other564.elapsed_ms; __isset = other564.__isset; +} +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other565) { + lockid = other565.lockid; + txnid = other565.txnid; + elapsed_ms = other565.elapsed_ms; + __isset = other565.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -13249,11 +13313,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other565) { - lockid = other565.lockid; -} -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) { +UnlockRequest::UnlockRequest(const UnlockRequest& other566) { lockid = other566.lockid; +} +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) { + lockid = other567.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -13392,19 +13456,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other567) { - dbname = other567.dbname; - tablename = other567.tablename; - partname = other567.partname; - isExtended = other567.isExtended; - __isset = other567.__isset; -} -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other568) { +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other568) { dbname = other568.dbname; tablename = other568.tablename; partname = other568.partname; isExtended = other568.isExtended; __isset = other568.__isset; +} +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other569) { + dbname = other569.dbname; + tablename = other569.tablename; + partname = other569.partname; + isExtended = other569.isExtended; + __isset = other569.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13557,9 +13621,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast569; - xfer += iprot->readI32(ecast569); - this->state = (LockState::type)ecast569; + int32_t ecast570; + xfer += iprot->readI32(ecast570); + this->state = (LockState::type)ecast570; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13567,9 +13631,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast570; - xfer += iprot->readI32(ecast570); - this->type = (LockType::type)ecast570; + int32_t ecast571; + xfer += iprot->readI32(ecast571); + this->type = (LockType::type)ecast571; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13785,26 +13849,7 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other571) { - lockid = other571.lockid; - dbname = other571.dbname; - tablename = other571.tablename; - partname = other571.partname; - state = other571.state; - type = other571.type; - txnid = other571.txnid; - lastheartbeat = other571.lastheartbeat; - acquiredat = other571.acquiredat; - user = other571.user; - hostname = other571.hostname; - heartbeatCount = other571.heartbeatCount; - agentInfo = other571.agentInfo; - blockedByExtId = other571.blockedByExtId; - blockedByIntId = other571.blockedByIntId; - lockIdInternal = other571.lockIdInternal; - __isset = other571.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other572) { +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) { lockid = other572.lockid; dbname = other572.dbname; tablename = other572.tablename; @@ -13822,6 +13867,25 @@ ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksRes blockedByIntId = other572.blockedByIntId; lockIdInternal = other572.lockIdInternal; __isset = other572.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other573) { + lockid = other573.lockid; + dbname = other573.dbname; + tablename = other573.tablename; + partname = other573.partname; + state = other573.state; + type = other573.type; + txnid = other573.txnid; + lastheartbeat = other573.lastheartbeat; + acquiredat = other573.acquiredat; + user = other573.user; + hostname = other573.hostname; + heartbeatCount = other573.heartbeatCount; + agentInfo = other573.agentInfo; + blockedByExtId = other573.blockedByExtId; + blockedByIntId = other573.blockedByIntId; + lockIdInternal = other573.lockIdInternal; + __isset = other573.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -13880,14 +13944,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size573; - ::apache::thrift::protocol::TType _etype576; - xfer += iprot->readListBegin(_etype576, _size573); - this->locks.resize(_size573); - uint32_t _i577; - for (_i577 = 0; _i577 < _size573; ++_i577) + uint32_t _size574; + ::apache::thrift::protocol::TType _etype577; + xfer += iprot->readListBegin(_etype577, _size574); + this->locks.resize(_size574); + uint32_t _i578; + for (_i578 = 0; _i578 < _size574; ++_i578) { - xfer += this->locks[_i577].read(iprot); + xfer += this->locks[_i578].read(iprot); } xfer += iprot->readListEnd(); } @@ -13916,10 +13980,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); - std::vector ::const_iterator _iter578; - for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578) + std::vector ::const_iterator _iter579; + for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579) { - xfer += (*_iter578).write(oprot); + xfer += (*_iter579).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13936,13 +14000,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) { - locks = other579.locks; - __isset = other579.__isset; -} -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other580) { +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other580) { locks = other580.locks; __isset = other580.__isset; +} +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other581) { + locks = other581.locks; + __isset = other581.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -14043,15 +14107,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) { - lockid = other581.lockid; - txnid = other581.txnid; - __isset = other581.__isset; -} -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other582) { +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other582) { lockid = other582.lockid; txnid = other582.txnid; __isset = other582.__isset; +} +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other583) { + lockid = other583.lockid; + txnid = other583.txnid; + __isset = other583.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -14154,13 +14218,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) { - min = other583.min; - max = other583.max; -} -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other584) { +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other584) { min = other584.min; max = other584.max; +} +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other585) { + min = other585.min; + max = other585.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -14211,15 +14275,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size585; - ::apache::thrift::protocol::TType _etype588; - xfer += iprot->readSetBegin(_etype588, _size585); - uint32_t _i589; - for (_i589 = 0; _i589 < _size585; ++_i589) + uint32_t _size586; + ::apache::thrift::protocol::TType _etype589; + xfer += iprot->readSetBegin(_etype589, _size586); + uint32_t _i590; + for (_i590 = 0; _i590 < _size586; ++_i590) { - int64_t _elem590; - xfer += iprot->readI64(_elem590); - this->aborted.insert(_elem590); + int64_t _elem591; + xfer += iprot->readI64(_elem591); + this->aborted.insert(_elem591); } xfer += iprot->readSetEnd(); } @@ -14232,15 +14296,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size591; - ::apache::thrift::protocol::TType _etype594; - xfer += iprot->readSetBegin(_etype594, _size591); - uint32_t _i595; - for (_i595 = 0; _i595 < _size591; ++_i595) + uint32_t _size592; + ::apache::thrift::protocol::TType _etype595; + xfer += iprot->readSetBegin(_etype595, _size592); + uint32_t _i596; + for (_i596 = 0; _i596 < _size592; ++_i596) { - int64_t _elem596; - xfer += iprot->readI64(_elem596); - this->nosuch.insert(_elem596); + int64_t _elem597; + xfer += iprot->readI64(_elem597); + this->nosuch.insert(_elem597); } xfer += iprot->readSetEnd(); } @@ -14273,10 +14337,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); - std::set ::const_iterator _iter597; - for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597) + std::set ::const_iterator _iter598; + for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598) { - xfer += oprot->writeI64((*_iter597)); + xfer += oprot->writeI64((*_iter598)); } xfer += oprot->writeSetEnd(); } @@ -14285,10 +14349,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); - std::set ::const_iterator _iter598; - for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598) + std::set ::const_iterator _iter599; + for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599) { - xfer += oprot->writeI64((*_iter598)); + xfer += oprot->writeI64((*_iter599)); } xfer += oprot->writeSetEnd(); } @@ -14305,13 +14369,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) { - aborted = other599.aborted; - nosuch = other599.nosuch; -} -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other600) { +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other600) { aborted = other600.aborted; nosuch = other600.nosuch; +} +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other601) { + aborted = other601.aborted; + nosuch = other601.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -14399,9 +14463,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast601; - xfer += iprot->readI32(ecast601); - this->type = (CompactionType::type)ecast601; + int32_t ecast602; + xfer += iprot->readI32(ecast602); + this->type = (CompactionType::type)ecast602; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14475,21 +14539,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other602) { - dbname = other602.dbname; - tablename = other602.tablename; - partitionname = other602.partitionname; - type = other602.type; - runas = other602.runas; - __isset = other602.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other603) { +CompactionRequest::CompactionRequest(const CompactionRequest& other603) { dbname = other603.dbname; tablename = other603.tablename; partitionname = other603.partitionname; type = other603.type; runas = other603.runas; __isset = other603.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other604) { + dbname = other604.dbname; + tablename = other604.tablename; + partitionname = other604.partitionname; + type = other604.type; + runas = other604.runas; + __isset = other604.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14552,11 +14616,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other604) { - (void) other604; -} -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other605) { +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other605) { (void) other605; +} +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other606) { + (void) other606; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -14677,9 +14741,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast606; - xfer += iprot->readI32(ecast606); - this->type = (CompactionType::type)ecast606; + int32_t ecast607; + xfer += iprot->readI32(ecast607); + this->type = (CompactionType::type)ecast607; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14852,22 +14916,7 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other607) { - dbname = other607.dbname; - tablename = other607.tablename; - partitionname = other607.partitionname; - type = other607.type; - state = other607.state; - workerid = other607.workerid; - start = other607.start; - runAs = other607.runAs; - hightestTxnId = other607.hightestTxnId; - metaInfo = other607.metaInfo; - endTime = other607.endTime; - hadoopJobId = other607.hadoopJobId; - __isset = other607.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other608) { +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other608) { dbname = other608.dbname; tablename = other608.tablename; partitionname = other608.partitionname; @@ -14881,6 +14930,21 @@ ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowComp endTime = other608.endTime; hadoopJobId = other608.hadoopJobId; __isset = other608.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other609) { + dbname = other609.dbname; + tablename = other609.tablename; + partitionname = other609.partitionname; + type = other609.type; + state = other609.state; + workerid = other609.workerid; + start = other609.start; + runAs = other609.runAs; + hightestTxnId = other609.hightestTxnId; + metaInfo = other609.metaInfo; + endTime = other609.endTime; + hadoopJobId = other609.hadoopJobId; + __isset = other609.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -14936,14 +15000,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size609; - ::apache::thrift::protocol::TType _etype612; - xfer += iprot->readListBegin(_etype612, _size609); - this->compacts.resize(_size609); - uint32_t _i613; - for (_i613 = 0; _i613 < _size609; ++_i613) + uint32_t _size610; + ::apache::thrift::protocol::TType _etype613; + xfer += iprot->readListBegin(_etype613, _size610); + this->compacts.resize(_size610); + uint32_t _i614; + for (_i614 = 0; _i614 < _size610; ++_i614) { - xfer += this->compacts[_i613].read(iprot); + xfer += this->compacts[_i614].read(iprot); } xfer += iprot->readListEnd(); } @@ -14974,10 +15038,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); - std::vector ::const_iterator _iter614; - for (_iter614 = this->compacts.begin(); _iter614 != this->compacts.end(); ++_iter614) + std::vector ::const_iterator _iter615; + for (_iter615 = this->compacts.begin(); _iter615 != this->compacts.end(); ++_iter615) { - xfer += (*_iter614).write(oprot); + xfer += (*_iter615).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14993,11 +15057,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other615) { - compacts = other615.compacts; -} -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other616) { +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other616) { compacts = other616.compacts; +} +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other617) { + compacts = other617.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15028,6 +15092,11 @@ void AddDynamicPartitions::__set_partitionnames(const std::vector & this->partitionnames = val; } +void AddDynamicPartitions::__set_operationType(const DataOperationType::type val) { + this->operationType = val; +__isset.operationType = true; +} + uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -15081,14 +15150,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size617; - ::apache::thrift::protocol::TType _etype620; - xfer += iprot->readListBegin(_etype620, _size617); - this->partitionnames.resize(_size617); - uint32_t _i621; - for (_i621 = 0; _i621 < _size617; ++_i621) + uint32_t _size618; + ::apache::thrift::protocol::TType _etype621; + xfer += iprot->readListBegin(_etype621, _size618); + this->partitionnames.resize(_size618); + uint32_t _i622; + for (_i622 = 0; _i622 < _size618; ++_i622) { - xfer += iprot->readString(this->partitionnames[_i621]); + xfer += iprot->readString(this->partitionnames[_i622]); } xfer += iprot->readListEnd(); } @@ -15097,6 +15166,16 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast623; + xfer += iprot->readI32(ecast623); + this->operationType = (DataOperationType::type)ecast623; + this->__isset.operationType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -15137,15 +15216,20 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter622; - for (_iter622 = this->partitionnames.begin(); _iter622 != this->partitionnames.end(); ++_iter622) + std::vector ::const_iterator _iter624; + for (_iter624 = this->partitionnames.begin(); _iter624 != this->partitionnames.end(); ++_iter624) { - xfer += oprot->writeString((*_iter622)); + xfer += oprot->writeString((*_iter624)); } xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); + if (this->__isset.operationType) { + xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32((int32_t)this->operationType); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -15157,19 +15241,25 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.dbname, b.dbname); swap(a.tablename, b.tablename); swap(a.partitionnames, b.partitionnames); + swap(a.operationType, b.operationType); + swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other623) { - txnid = other623.txnid; - dbname = other623.dbname; - tablename = other623.tablename; - partitionnames = other623.partitionnames; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other625) { + txnid = other625.txnid; + dbname = other625.dbname; + tablename = other625.tablename; + partitionnames = other625.partitionnames; + operationType = other625.operationType; + __isset = other625.__isset; } -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other624) { - txnid = other624.txnid; - dbname = other624.dbname; - tablename = other624.tablename; - partitionnames = other624.partitionnames; +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other626) { + txnid = other626.txnid; + dbname = other626.dbname; + tablename = other626.tablename; + partitionnames = other626.partitionnames; + operationType = other626.operationType; + __isset = other626.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -15179,6 +15269,7 @@ void AddDynamicPartitions::printTo(std::ostream& out) const { out << ", " << "dbname=" << to_string(dbname); out << ", " << "tablename=" << to_string(tablename); out << ", " << "partitionnames=" << to_string(partitionnames); + out << ", " << "operationType="; (__isset.operationType ? (out << to_string(operationType)) : (out << "")); out << ")"; } @@ -15274,15 +15365,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other625) { - lastEvent = other625.lastEvent; - maxEvents = other625.maxEvents; - __isset = other625.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other627) { + lastEvent = other627.lastEvent; + maxEvents = other627.maxEvents; + __isset = other627.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other626) { - lastEvent = other626.lastEvent; - maxEvents = other626.maxEvents; - __isset = other626.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other628) { + lastEvent = other628.lastEvent; + maxEvents = other628.maxEvents; + __isset = other628.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -15464,23 +15555,23 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other627) { - eventId = other627.eventId; - eventTime = other627.eventTime; - eventType = other627.eventType; - dbName = other627.dbName; - tableName = other627.tableName; - message = other627.message; - __isset = other627.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other628) { - eventId = other628.eventId; - eventTime = other628.eventTime; - eventType = other628.eventType; - dbName = other628.dbName; - tableName = other628.tableName; - message = other628.message; - __isset = other628.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other629) { + eventId = other629.eventId; + eventTime = other629.eventTime; + eventType = other629.eventType; + dbName = other629.dbName; + tableName = other629.tableName; + message = other629.message; + __isset = other629.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other630) { + eventId = other630.eventId; + eventTime = other630.eventTime; + eventType = other630.eventType; + dbName = other630.dbName; + tableName = other630.tableName; + message = other630.message; + __isset = other630.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15530,14 +15621,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size629; - ::apache::thrift::protocol::TType _etype632; - xfer += iprot->readListBegin(_etype632, _size629); - this->events.resize(_size629); - uint32_t _i633; - for (_i633 = 0; _i633 < _size629; ++_i633) + uint32_t _size631; + ::apache::thrift::protocol::TType _etype634; + xfer += iprot->readListBegin(_etype634, _size631); + this->events.resize(_size631); + uint32_t _i635; + for (_i635 = 0; _i635 < _size631; ++_i635) { - xfer += this->events[_i633].read(iprot); + xfer += this->events[_i635].read(iprot); } xfer += iprot->readListEnd(); } @@ -15568,10 +15659,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); - std::vector ::const_iterator _iter634; - for (_iter634 = this->events.begin(); _iter634 != this->events.end(); ++_iter634) + std::vector ::const_iterator _iter636; + for (_iter636 = this->events.begin(); _iter636 != this->events.end(); ++_iter636) { - xfer += (*_iter634).write(oprot); + xfer += (*_iter636).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15587,11 +15678,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other635) { - events = other635.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other637) { + events = other637.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other636) { - events = other636.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other638) { + events = other638.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -15673,11 +15764,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other637) { - eventId = other637.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other639) { + eventId = other639.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other638) { - eventId = other638.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other640) { + eventId = other640.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -15722,14 +15813,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size639; - ::apache::thrift::protocol::TType _etype642; - xfer += iprot->readListBegin(_etype642, _size639); - this->filesAdded.resize(_size639); - uint32_t _i643; - for (_i643 = 0; _i643 < _size639; ++_i643) + uint32_t _size641; + ::apache::thrift::protocol::TType _etype644; + xfer += iprot->readListBegin(_etype644, _size641); + this->filesAdded.resize(_size641); + uint32_t _i645; + for (_i645 = 0; _i645 < _size641; ++_i645) { - xfer += iprot->readString(this->filesAdded[_i643]); + xfer += iprot->readString(this->filesAdded[_i645]); } xfer += iprot->readListEnd(); } @@ -15760,10 +15851,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter644; - for (_iter644 = this->filesAdded.begin(); _iter644 != this->filesAdded.end(); ++_iter644) + std::vector ::const_iterator _iter646; + for (_iter646 = this->filesAdded.begin(); _iter646 != this->filesAdded.end(); ++_iter646) { - xfer += oprot->writeString((*_iter644)); + xfer += oprot->writeString((*_iter646)); } xfer += oprot->writeListEnd(); } @@ -15779,11 +15870,11 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.filesAdded, b.filesAdded); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other645) { - filesAdded = other645.filesAdded; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other647) { + filesAdded = other647.filesAdded; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other646) { - filesAdded = other646.filesAdded; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other648) { + filesAdded = other648.filesAdded; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -15863,13 +15954,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other647) { - insertData = other647.insertData; - __isset = other647.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other649) { + insertData = other649.insertData; + __isset = other649.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other648) { - insertData = other648.insertData; - __isset = other648.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other650) { + insertData = other650.insertData; + __isset = other650.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -15966,14 +16057,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->partitionVals.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->partitionVals.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) { - xfer += iprot->readString(this->partitionVals[_i653]); + xfer += iprot->readString(this->partitionVals[_i655]); } xfer += iprot->readListEnd(); } @@ -16025,10 +16116,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter654; - for (_iter654 = this->partitionVals.begin(); _iter654 != this->partitionVals.end(); ++_iter654) + std::vector ::const_iterator _iter656; + for (_iter656 = this->partitionVals.begin(); _iter656 != this->partitionVals.end(); ++_iter656) { - xfer += oprot->writeString((*_iter654)); + xfer += oprot->writeString((*_iter656)); } xfer += oprot->writeListEnd(); } @@ -16049,21 +16140,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other655) { - successful = other655.successful; - data = other655.data; - dbName = other655.dbName; - tableName = other655.tableName; - partitionVals = other655.partitionVals; - __isset = other655.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other656) { - successful = other656.successful; - data = other656.data; - dbName = other656.dbName; - tableName = other656.tableName; - partitionVals = other656.partitionVals; - __isset = other656.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other657) { + successful = other657.successful; + data = other657.data; + dbName = other657.dbName; + tableName = other657.tableName; + partitionVals = other657.partitionVals; + __isset = other657.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other658) { + successful = other658.successful; + data = other658.data; + dbName = other658.dbName; + tableName = other658.tableName; + partitionVals = other658.partitionVals; + __isset = other658.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16126,11 +16217,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other657) { - (void) other657; +FireEventResponse::FireEventResponse(const FireEventResponse& other659) { + (void) other659; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other658) { - (void) other658; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other660) { + (void) other660; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16230,15 +16321,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other659) { - metadata = other659.metadata; - includeBitset = other659.includeBitset; - __isset = other659.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other661) { + metadata = other661.metadata; + includeBitset = other661.includeBitset; + __isset = other661.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other660) { - metadata = other660.metadata; - includeBitset = other660.includeBitset; - __isset = other660.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other662) { + metadata = other662.metadata; + includeBitset = other662.includeBitset; + __isset = other662.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16289,17 +16380,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size661; - ::apache::thrift::protocol::TType _ktype662; - ::apache::thrift::protocol::TType _vtype663; - xfer += iprot->readMapBegin(_ktype662, _vtype663, _size661); - uint32_t _i665; - for (_i665 = 0; _i665 < _size661; ++_i665) + uint32_t _size663; + ::apache::thrift::protocol::TType _ktype664; + ::apache::thrift::protocol::TType _vtype665; + xfer += iprot->readMapBegin(_ktype664, _vtype665, _size663); + uint32_t _i667; + for (_i667 = 0; _i667 < _size663; ++_i667) { - int64_t _key666; - xfer += iprot->readI64(_key666); - MetadataPpdResult& _val667 = this->metadata[_key666]; - xfer += _val667.read(iprot); + int64_t _key668; + xfer += iprot->readI64(_key668); + MetadataPpdResult& _val669 = this->metadata[_key668]; + xfer += _val669.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16340,11 +16431,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter668; - for (_iter668 = this->metadata.begin(); _iter668 != this->metadata.end(); ++_iter668) + std::map ::const_iterator _iter670; + for (_iter670 = this->metadata.begin(); _iter670 != this->metadata.end(); ++_iter670) { - xfer += oprot->writeI64(_iter668->first); - xfer += _iter668->second.write(oprot); + xfer += oprot->writeI64(_iter670->first); + xfer += _iter670->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16365,13 +16456,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other669) { - metadata = other669.metadata; - isSupported = other669.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other671) { + metadata = other671.metadata; + isSupported = other671.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other670) { - metadata = other670.metadata; - isSupported = other670.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other672) { + metadata = other672.metadata; + isSupported = other672.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16432,14 +16523,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size671; - ::apache::thrift::protocol::TType _etype674; - xfer += iprot->readListBegin(_etype674, _size671); - this->fileIds.resize(_size671); - uint32_t _i675; - for (_i675 = 0; _i675 < _size671; ++_i675) + uint32_t _size673; + ::apache::thrift::protocol::TType _etype676; + xfer += iprot->readListBegin(_etype676, _size673); + this->fileIds.resize(_size673); + uint32_t _i677; + for (_i677 = 0; _i677 < _size673; ++_i677) { - xfer += iprot->readI64(this->fileIds[_i675]); + xfer += iprot->readI64(this->fileIds[_i677]); } xfer += iprot->readListEnd(); } @@ -16466,9 +16557,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast676; - xfer += iprot->readI32(ecast676); - this->type = (FileMetadataExprType::type)ecast676; + int32_t ecast678; + xfer += iprot->readI32(ecast678); + this->type = (FileMetadataExprType::type)ecast678; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16498,10 +16589,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter677; - for (_iter677 = this->fileIds.begin(); _iter677 != this->fileIds.end(); ++_iter677) + std::vector ::const_iterator _iter679; + for (_iter679 = this->fileIds.begin(); _iter679 != this->fileIds.end(); ++_iter679) { - xfer += oprot->writeI64((*_iter677)); + xfer += oprot->writeI64((*_iter679)); } xfer += oprot->writeListEnd(); } @@ -16535,19 +16626,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other678) { - fileIds = other678.fileIds; - expr = other678.expr; - doGetFooters = other678.doGetFooters; - type = other678.type; - __isset = other678.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other680) { + fileIds = other680.fileIds; + expr = other680.expr; + doGetFooters = other680.doGetFooters; + type = other680.type; + __isset = other680.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other679) { - fileIds = other679.fileIds; - expr = other679.expr; - doGetFooters = other679.doGetFooters; - type = other679.type; - __isset = other679.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other681) { + fileIds = other681.fileIds; + expr = other681.expr; + doGetFooters = other681.doGetFooters; + type = other681.type; + __isset = other681.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -16600,17 +16691,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size680; - ::apache::thrift::protocol::TType _ktype681; - ::apache::thrift::protocol::TType _vtype682; - xfer += iprot->readMapBegin(_ktype681, _vtype682, _size680); - uint32_t _i684; - for (_i684 = 0; _i684 < _size680; ++_i684) + uint32_t _size682; + ::apache::thrift::protocol::TType _ktype683; + ::apache::thrift::protocol::TType _vtype684; + xfer += iprot->readMapBegin(_ktype683, _vtype684, _size682); + uint32_t _i686; + for (_i686 = 0; _i686 < _size682; ++_i686) { - int64_t _key685; - xfer += iprot->readI64(_key685); - std::string& _val686 = this->metadata[_key685]; - xfer += iprot->readBinary(_val686); + int64_t _key687; + xfer += iprot->readI64(_key687); + std::string& _val688 = this->metadata[_key687]; + xfer += iprot->readBinary(_val688); } xfer += iprot->readMapEnd(); } @@ -16651,11 +16742,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter687; - for (_iter687 = this->metadata.begin(); _iter687 != this->metadata.end(); ++_iter687) + std::map ::const_iterator _iter689; + for (_iter689 = this->metadata.begin(); _iter689 != this->metadata.end(); ++_iter689) { - xfer += oprot->writeI64(_iter687->first); - xfer += oprot->writeBinary(_iter687->second); + xfer += oprot->writeI64(_iter689->first); + xfer += oprot->writeBinary(_iter689->second); } xfer += oprot->writeMapEnd(); } @@ -16676,13 +16767,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other688) { - metadata = other688.metadata; - isSupported = other688.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other690) { + metadata = other690.metadata; + isSupported = other690.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other689) { - metadata = other689.metadata; - isSupported = other689.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other691) { + metadata = other691.metadata; + isSupported = other691.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -16728,14 +16819,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - this->fileIds.resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size692; + ::apache::thrift::protocol::TType _etype695; + xfer += iprot->readListBegin(_etype695, _size692); + this->fileIds.resize(_size692); + uint32_t _i696; + for (_i696 = 0; _i696 < _size692; ++_i696) { - xfer += iprot->readI64(this->fileIds[_i694]); + xfer += iprot->readI64(this->fileIds[_i696]); } xfer += iprot->readListEnd(); } @@ -16766,10 +16857,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter695; - for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695) + std::vector ::const_iterator _iter697; + for (_iter697 = this->fileIds.begin(); _iter697 != this->fileIds.end(); ++_iter697) { - xfer += oprot->writeI64((*_iter695)); + xfer += oprot->writeI64((*_iter697)); } xfer += oprot->writeListEnd(); } @@ -16785,11 +16876,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other696) { - fileIds = other696.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other698) { + fileIds = other698.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other697) { - fileIds = other697.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other699) { + fileIds = other699.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -16848,11 +16939,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other698) { - (void) other698; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other700) { + (void) other700; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other699) { - (void) other699; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other701) { + (void) other701; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -16906,14 +16997,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size700; - ::apache::thrift::protocol::TType _etype703; - xfer += iprot->readListBegin(_etype703, _size700); - this->fileIds.resize(_size700); - uint32_t _i704; - for (_i704 = 0; _i704 < _size700; ++_i704) + uint32_t _size702; + ::apache::thrift::protocol::TType _etype705; + xfer += iprot->readListBegin(_etype705, _size702); + this->fileIds.resize(_size702); + uint32_t _i706; + for (_i706 = 0; _i706 < _size702; ++_i706) { - xfer += iprot->readI64(this->fileIds[_i704]); + xfer += iprot->readI64(this->fileIds[_i706]); } xfer += iprot->readListEnd(); } @@ -16926,14 +17017,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size705; - ::apache::thrift::protocol::TType _etype708; - xfer += iprot->readListBegin(_etype708, _size705); - this->metadata.resize(_size705); - uint32_t _i709; - for (_i709 = 0; _i709 < _size705; ++_i709) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readListBegin(_etype710, _size707); + this->metadata.resize(_size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - xfer += iprot->readBinary(this->metadata[_i709]); + xfer += iprot->readBinary(this->metadata[_i711]); } xfer += iprot->readListEnd(); } @@ -16944,9 +17035,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast710; - xfer += iprot->readI32(ecast710); - this->type = (FileMetadataExprType::type)ecast710; + int32_t ecast712; + xfer += iprot->readI32(ecast712); + this->type = (FileMetadataExprType::type)ecast712; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16976,10 +17067,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter711; - for (_iter711 = this->fileIds.begin(); _iter711 != this->fileIds.end(); ++_iter711) + std::vector ::const_iterator _iter713; + for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713) { - xfer += oprot->writeI64((*_iter711)); + xfer += oprot->writeI64((*_iter713)); } xfer += oprot->writeListEnd(); } @@ -16988,10 +17079,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter712; - for (_iter712 = this->metadata.begin(); _iter712 != this->metadata.end(); ++_iter712) + std::vector ::const_iterator _iter714; + for (_iter714 = this->metadata.begin(); _iter714 != this->metadata.end(); ++_iter714) { - xfer += oprot->writeBinary((*_iter712)); + xfer += oprot->writeBinary((*_iter714)); } xfer += oprot->writeListEnd(); } @@ -17015,17 +17106,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other713) { - fileIds = other713.fileIds; - metadata = other713.metadata; - type = other713.type; - __isset = other713.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other715) { + fileIds = other715.fileIds; + metadata = other715.metadata; + type = other715.type; + __isset = other715.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other714) { - fileIds = other714.fileIds; - metadata = other714.metadata; - type = other714.type; - __isset = other714.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other716) { + fileIds = other716.fileIds; + metadata = other716.metadata; + type = other716.type; + __isset = other716.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17086,11 +17177,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other715) { - (void) other715; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other717) { + (void) other717; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other716) { - (void) other716; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other718) { + (void) other718; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17134,14 +17225,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size717; - ::apache::thrift::protocol::TType _etype720; - xfer += iprot->readListBegin(_etype720, _size717); - this->fileIds.resize(_size717); - uint32_t _i721; - for (_i721 = 0; _i721 < _size717; ++_i721) + uint32_t _size719; + ::apache::thrift::protocol::TType _etype722; + xfer += iprot->readListBegin(_etype722, _size719); + this->fileIds.resize(_size719); + uint32_t _i723; + for (_i723 = 0; _i723 < _size719; ++_i723) { - xfer += iprot->readI64(this->fileIds[_i721]); + xfer += iprot->readI64(this->fileIds[_i723]); } xfer += iprot->readListEnd(); } @@ -17172,10 +17263,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter722; - for (_iter722 = this->fileIds.begin(); _iter722 != this->fileIds.end(); ++_iter722) + std::vector ::const_iterator _iter724; + for (_iter724 = this->fileIds.begin(); _iter724 != this->fileIds.end(); ++_iter724) { - xfer += oprot->writeI64((*_iter722)); + xfer += oprot->writeI64((*_iter724)); } xfer += oprot->writeListEnd(); } @@ -17191,11 +17282,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other723) { - fileIds = other723.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other725) { + fileIds = other725.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other724) { - fileIds = other724.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other726) { + fileIds = other726.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17277,11 +17368,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other725) { - isSupported = other725.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other727) { + isSupported = other727.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other726) { - isSupported = other726.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other728) { + isSupported = other728.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17422,19 +17513,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other727) { - dbName = other727.dbName; - tblName = other727.tblName; - partName = other727.partName; - isAllParts = other727.isAllParts; - __isset = other727.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other729) { + dbName = other729.dbName; + tblName = other729.tblName; + partName = other729.partName; + isAllParts = other729.isAllParts; + __isset = other729.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other728) { - dbName = other728.dbName; - tblName = other728.tblName; - partName = other728.partName; - isAllParts = other728.isAllParts; - __isset = other728.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other730) { + dbName = other730.dbName; + tblName = other730.tblName; + partName = other730.partName; + isAllParts = other730.isAllParts; + __isset = other730.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17482,14 +17573,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size729; - ::apache::thrift::protocol::TType _etype732; - xfer += iprot->readListBegin(_etype732, _size729); - this->functions.resize(_size729); - uint32_t _i733; - for (_i733 = 0; _i733 < _size729; ++_i733) + uint32_t _size731; + ::apache::thrift::protocol::TType _etype734; + xfer += iprot->readListBegin(_etype734, _size731); + this->functions.resize(_size731); + uint32_t _i735; + for (_i735 = 0; _i735 < _size731; ++_i735) { - xfer += this->functions[_i733].read(iprot); + xfer += this->functions[_i735].read(iprot); } xfer += iprot->readListEnd(); } @@ -17519,10 +17610,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter734; - for (_iter734 = this->functions.begin(); _iter734 != this->functions.end(); ++_iter734) + std::vector ::const_iterator _iter736; + for (_iter736 = this->functions.begin(); _iter736 != this->functions.end(); ++_iter736) { - xfer += (*_iter734).write(oprot); + xfer += (*_iter736).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17539,13 +17630,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other735) { - functions = other735.functions; - __isset = other735.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other737) { + functions = other737.functions; + __isset = other737.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other736) { - functions = other736.functions; - __isset = other736.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other738) { + functions = other738.functions; + __isset = other738.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -17687,19 +17778,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other737) { - dbName = other737.dbName; - tableName = other737.tableName; - tableType = other737.tableType; - comments = other737.comments; - __isset = other737.__isset; +TableMeta::TableMeta(const TableMeta& other739) { + dbName = other739.dbName; + tableName = other739.tableName; + tableType = other739.tableType; + comments = other739.comments; + __isset = other739.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other738) { - dbName = other738.dbName; - tableName = other738.tableName; - tableType = other738.tableType; - comments = other738.comments; - __isset = other738.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other740) { + dbName = other740.dbName; + tableName = other740.tableName; + tableType = other740.tableType; + comments = other740.comments; + __isset = other740.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -17782,13 +17873,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other739) : TException() { - message = other739.message; - __isset = other739.__isset; +MetaException::MetaException(const MetaException& other741) : TException() { + message = other741.message; + __isset = other741.__isset; } -MetaException& MetaException::operator=(const MetaException& other740) { - message = other740.message; - __isset = other740.__isset; +MetaException& MetaException::operator=(const MetaException& other742) { + message = other742.message; + __isset = other742.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -17879,13 +17970,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other741) : TException() { - message = other741.message; - __isset = other741.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other743) : TException() { + message = other743.message; + __isset = other743.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other742) { - message = other742.message; - __isset = other742.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other744) { + message = other744.message; + __isset = other744.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -17976,13 +18067,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other743) : TException() { - message = other743.message; - __isset = other743.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other745) : TException() { + message = other745.message; + __isset = other745.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other744) { - message = other744.message; - __isset = other744.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other746) { + message = other746.message; + __isset = other746.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -18073,13 +18164,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other745) : TException() { - message = other745.message; - __isset = other745.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other747) : TException() { + message = other747.message; + __isset = other747.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other746) { - message = other746.message; - __isset = other746.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other748) { + message = other748.message; + __isset = other748.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -18170,13 +18261,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other747) : TException() { - message = other747.message; - __isset = other747.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other749) : TException() { + message = other749.message; + __isset = other749.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other748) { - message = other748.message; - __isset = other748.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other750) { + message = other750.message; + __isset = other750.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -18267,13 +18358,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other749) : TException() { - message = other749.message; - __isset = other749.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other751) : TException() { + message = other751.message; + __isset = other751.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other750) { - message = other750.message; - __isset = other750.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other752) { + message = other752.message; + __isset = other752.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -18364,13 +18455,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other751) : TException() { - message = other751.message; - __isset = other751.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other753) : TException() { + message = other753.message; + __isset = other753.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other752) { - message = other752.message; - __isset = other752.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other754) { + message = other754.message; + __isset = other754.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -18461,13 +18552,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other753) : TException() { - message = other753.message; - __isset = other753.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other755) : TException() { + message = other755.message; + __isset = other755.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other754) { - message = other754.message; - __isset = other754.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other756) { + message = other756.message; + __isset = other756.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -18558,13 +18649,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other755) : TException() { - message = other755.message; - __isset = other755.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other757) : TException() { + message = other757.message; + __isset = other757.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other756) { - message = other756.message; - __isset = other756.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other758) { + message = other758.message; + __isset = other758.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -18655,13 +18746,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other757) : TException() { - message = other757.message; - __isset = other757.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other759) : TException() { + message = other759.message; + __isset = other759.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other758) { - message = other758.message; - __isset = other758.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other760) { + message = other760.message; + __isset = other760.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -18752,13 +18843,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other759) : TException() { - message = other759.message; - __isset = other759.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other761) : TException() { + message = other761.message; + __isset = other761.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other760) { - message = other760.message; - __isset = other760.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other762) { + message = other762.message; + __isset = other762.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -18849,13 +18940,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other761) : TException() { - message = other761.message; - __isset = other761.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other763) : TException() { + message = other763.message; + __isset = other763.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other762) { - message = other762.message; - __isset = other762.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other764) { + message = other764.message; + __isset = other764.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -18946,13 +19037,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other763) : TException() { - message = other763.message; - __isset = other763.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other765) : TException() { + message = other765.message; + __isset = other765.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other764) { - message = other764.message; - __isset = other764.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other766) { + message = other766.message; + __isset = other766.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -19043,13 +19134,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other765) : TException() { - message = other765.message; - __isset = other765.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other767) : TException() { + message = other767.message; + __isset = other767.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other766) { - message = other766.message; - __isset = other766.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other768) { + message = other768.message; + __isset = other768.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -19140,13 +19231,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other767) : TException() { - message = other767.message; - __isset = other767.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other769) : TException() { + message = other769.message; + __isset = other769.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other768) { - message = other768.message; - __isset = other768.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other770) { + message = other770.message; + __isset = other770.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -19237,13 +19328,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other769) : TException() { - message = other769.message; - __isset = other769.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other771) : TException() { + message = other771.message; + __isset = other771.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other770) { - message = other770.message; - __isset = other770.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other772) { + message = other772.message; + __isset = other772.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 883f266..00f017b 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -109,6 +109,19 @@ struct GrantRevokeType { extern const std::map _GrantRevokeType_VALUES_TO_NAMES; +struct DataOperationType { + enum type { + SELECT = 1, + INSERT = 2, + UPDATE = 3, + DELETE = 4, + UNSET = 5, + NO_TXN = 6 + }; +}; + +extern const std::map _DataOperationType_VALUES_TO_NAMES; + struct EventRequestType { enum type { INSERT = 1, @@ -5137,9 +5150,11 @@ inline std::ostream& operator<<(std::ostream& out, const CommitTxnRequest& obj) } typedef struct _LockComponent__isset { - _LockComponent__isset() : tablename(false), partitionname(false) {} + _LockComponent__isset() : tablename(false), partitionname(false), operationType(true), isAcid(true) {} bool tablename :1; bool partitionname :1; + bool operationType :1; + bool isAcid :1; } _LockComponent__isset; class LockComponent { @@ -5147,7 +5162,9 @@ class LockComponent { LockComponent(const LockComponent&); LockComponent& operator=(const LockComponent&); - LockComponent() : type((LockType::type)0), level((LockLevel::type)0), dbname(), tablename(), partitionname() { + LockComponent() : type((LockType::type)0), level((LockLevel::type)0), dbname(), tablename(), partitionname(), operationType((DataOperationType::type)5), isAcid(false) { + operationType = (DataOperationType::type)5; + } virtual ~LockComponent() throw(); @@ -5156,6 +5173,8 @@ class LockComponent { std::string dbname; std::string tablename; std::string partitionname; + DataOperationType::type operationType; + bool isAcid; _LockComponent__isset __isset; @@ -5169,6 +5188,10 @@ class LockComponent { void __set_partitionname(const std::string& val); + void __set_operationType(const DataOperationType::type val); + + void __set_isAcid(const bool val); + bool operator == (const LockComponent & rhs) const { if (!(type == rhs.type)) @@ -5185,6 +5208,14 @@ class LockComponent { return false; else if (__isset.partitionname && !(partitionname == rhs.partitionname)) return false; + if (__isset.operationType != rhs.__isset.operationType) + return false; + else if (__isset.operationType && !(operationType == rhs.operationType)) + return false; + if (__isset.isAcid != rhs.__isset.isAcid) + return false; + else if (__isset.isAcid && !(isAcid == rhs.isAcid)) + return false; return true; } bool operator != (const LockComponent &rhs) const { @@ -6105,13 +6136,19 @@ inline std::ostream& operator<<(std::ostream& out, const ShowCompactResponse& ob return out; } +typedef struct _AddDynamicPartitions__isset { + _AddDynamicPartitions__isset() : operationType(true) {} + bool operationType :1; +} _AddDynamicPartitions__isset; class AddDynamicPartitions { public: AddDynamicPartitions(const AddDynamicPartitions&); AddDynamicPartitions& operator=(const AddDynamicPartitions&); - AddDynamicPartitions() : txnid(0), dbname(), tablename() { + AddDynamicPartitions() : txnid(0), dbname(), tablename(), operationType((DataOperationType::type)5) { + operationType = (DataOperationType::type)5; + } virtual ~AddDynamicPartitions() throw(); @@ -6119,6 +6156,9 @@ class AddDynamicPartitions { std::string dbname; std::string tablename; std::vector partitionnames; + DataOperationType::type operationType; + + _AddDynamicPartitions__isset __isset; void __set_txnid(const int64_t val); @@ -6128,6 +6168,8 @@ class AddDynamicPartitions { void __set_partitionnames(const std::vector & val); + void __set_operationType(const DataOperationType::type val); + bool operator == (const AddDynamicPartitions & rhs) const { if (!(txnid == rhs.txnid)) @@ -6138,6 +6180,10 @@ class AddDynamicPartitions { return false; if (!(partitionnames == rhs.partitionnames)) return false; + if (__isset.operationType != rhs.__isset.operationType) + return false; + else if (__isset.operationType && !(operationType == rhs.operationType)) + return false; return true; } bool operator != (const AddDynamicPartitions &rhs) const { diff --git metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java index 544eff1..734a6df 100644 --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java @@ -42,6 +42,7 @@ private static final org.apache.thrift.protocol.TField DBNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbname", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField TABLENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tablename", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField PARTITIONNAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionnames", org.apache.thrift.protocol.TType.LIST, (short)4); + private static final org.apache.thrift.protocol.TField OPERATION_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("operationType", org.apache.thrift.protocol.TType.I32, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -53,13 +54,19 @@ private String dbname; // required private String tablename; // required private List partitionnames; // required + private DataOperationType operationType; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { TXNID((short)1, "txnid"), DBNAME((short)2, "dbname"), TABLENAME((short)3, "tablename"), - PARTITIONNAMES((short)4, "partitionnames"); + PARTITIONNAMES((short)4, "partitionnames"), + /** + * + * @see DataOperationType + */ + OPERATION_TYPE((short)5, "operationType"); private static final Map byName = new HashMap(); @@ -82,6 +89,8 @@ public static _Fields findByThriftId(int fieldId) { return TABLENAME; case 4: // PARTITIONNAMES return PARTITIONNAMES; + case 5: // OPERATION_TYPE + return OPERATION_TYPE; default: return null; } @@ -124,6 +133,7 @@ public String getFieldName() { // isset id assignments private static final int __TXNID_ISSET_ID = 0; private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.OPERATION_TYPE}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); @@ -136,11 +146,15 @@ public String getFieldName() { tmpMap.put(_Fields.PARTITIONNAMES, new org.apache.thrift.meta_data.FieldMetaData("partitionnames", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.OPERATION_TYPE, new org.apache.thrift.meta_data.FieldMetaData("operationType", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DataOperationType.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AddDynamicPartitions.class, metaDataMap); } public AddDynamicPartitions() { + this.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.UNSET; + } public AddDynamicPartitions( @@ -173,6 +187,9 @@ public AddDynamicPartitions(AddDynamicPartitions other) { List __this__partitionnames = new ArrayList(other.partitionnames); this.partitionnames = __this__partitionnames; } + if (other.isSetOperationType()) { + this.operationType = other.operationType; + } } public AddDynamicPartitions deepCopy() { @@ -186,6 +203,8 @@ public void clear() { this.dbname = null; this.tablename = null; this.partitionnames = null; + this.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.UNSET; + } public long getTxnid() { @@ -294,6 +313,37 @@ public void setPartitionnamesIsSet(boolean value) { } } + /** + * + * @see DataOperationType + */ + public DataOperationType getOperationType() { + return this.operationType; + } + + /** + * + * @see DataOperationType + */ + public void setOperationType(DataOperationType operationType) { + this.operationType = operationType; + } + + public void unsetOperationType() { + this.operationType = null; + } + + /** Returns true if field operationType is set (has been assigned a value) and false otherwise */ + public boolean isSetOperationType() { + return this.operationType != null; + } + + public void setOperationTypeIsSet(boolean value) { + if (!value) { + this.operationType = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TXNID: @@ -328,6 +378,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case OPERATION_TYPE: + if (value == null) { + unsetOperationType(); + } else { + setOperationType((DataOperationType)value); + } + break; + } } @@ -345,6 +403,9 @@ public Object getFieldValue(_Fields field) { case PARTITIONNAMES: return getPartitionnames(); + case OPERATION_TYPE: + return getOperationType(); + } throw new IllegalStateException(); } @@ -364,6 +425,8 @@ public boolean isSet(_Fields field) { return isSetTablename(); case PARTITIONNAMES: return isSetPartitionnames(); + case OPERATION_TYPE: + return isSetOperationType(); } throw new IllegalStateException(); } @@ -417,6 +480,15 @@ public boolean equals(AddDynamicPartitions that) { return false; } + boolean this_present_operationType = true && this.isSetOperationType(); + boolean that_present_operationType = true && that.isSetOperationType(); + if (this_present_operationType || that_present_operationType) { + if (!(this_present_operationType && that_present_operationType)) + return false; + if (!this.operationType.equals(that.operationType)) + return false; + } + return true; } @@ -444,6 +516,11 @@ public int hashCode() { if (present_partitionnames) list.add(partitionnames); + boolean present_operationType = true && (isSetOperationType()); + list.add(present_operationType); + if (present_operationType) + list.add(operationType.getValue()); + return list.hashCode(); } @@ -495,6 +572,16 @@ public int compareTo(AddDynamicPartitions other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetOperationType()).compareTo(other.isSetOperationType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOperationType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.operationType, other.operationType); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -542,6 +629,16 @@ public String toString() { sb.append(this.partitionnames); } first = false; + if (isSetOperationType()) { + if (!first) sb.append(", "); + sb.append("operationType:"); + if (this.operationType == null) { + sb.append("null"); + } else { + sb.append(this.operationType); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -645,6 +742,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AddDynamicPartition org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 5: // OPERATION_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.findByValue(iprot.readI32()); + struct.setOperationTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -683,6 +788,13 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AddDynamicPartitio } oprot.writeFieldEnd(); } + if (struct.operationType != null) { + if (struct.isSetOperationType()) { + oprot.writeFieldBegin(OPERATION_TYPE_FIELD_DESC); + oprot.writeI32(struct.operationType.getValue()); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -710,6 +822,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AddDynamicPartition oprot.writeString(_iter536); } } + BitSet optionals = new BitSet(); + if (struct.isSetOperationType()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetOperationType()) { + oprot.writeI32(struct.operationType.getValue()); + } } @Override @@ -732,6 +852,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, AddDynamicPartitions } } struct.setPartitionnamesIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.findByValue(iprot.readI32()); + struct.setOperationTypeIsSet(true); + } } } diff --git metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DataOperationType.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DataOperationType.java new file mode 100644 index 0000000..15a6e9a --- /dev/null +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DataOperationType.java @@ -0,0 +1,57 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + + +import java.util.Map; +import java.util.HashMap; +import org.apache.thrift.TEnum; + +public enum DataOperationType implements org.apache.thrift.TEnum { + SELECT(1), + INSERT(2), + UPDATE(3), + DELETE(4), + UNSET(5), + NO_TXN(6); + + private final int value; + + private DataOperationType(int value) { + this.value = value; + } + + /** + * Get the integer value of this enum value, as defined in the Thrift IDL. + */ + public int getValue() { + return value; + } + + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static DataOperationType findByValue(int value) { + switch (value) { + case 1: + return SELECT; + case 2: + return INSERT; + case 3: + return UPDATE; + case 4: + return DELETE; + case 5: + return UNSET; + case 6: + return NO_TXN; + default: + return null; + } + } +} diff --git metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java index adb0c44..26d1b76 100644 --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java @@ -43,6 +43,8 @@ private static final org.apache.thrift.protocol.TField DBNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbname", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField TABLENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tablename", org.apache.thrift.protocol.TType.STRING, (short)4); private static final org.apache.thrift.protocol.TField PARTITIONNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionname", org.apache.thrift.protocol.TType.STRING, (short)5); + private static final org.apache.thrift.protocol.TField OPERATION_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("operationType", org.apache.thrift.protocol.TType.I32, (short)6); + private static final org.apache.thrift.protocol.TField IS_ACID_FIELD_DESC = new org.apache.thrift.protocol.TField("isAcid", org.apache.thrift.protocol.TType.BOOL, (short)7); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -55,6 +57,8 @@ private String dbname; // required private String tablename; // optional private String partitionname; // optional + private DataOperationType operationType; // optional + private boolean isAcid; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -70,7 +74,13 @@ LEVEL((short)2, "level"), DBNAME((short)3, "dbname"), TABLENAME((short)4, "tablename"), - PARTITIONNAME((short)5, "partitionname"); + PARTITIONNAME((short)5, "partitionname"), + /** + * + * @see DataOperationType + */ + OPERATION_TYPE((short)6, "operationType"), + IS_ACID((short)7, "isAcid"); private static final Map byName = new HashMap(); @@ -95,6 +105,10 @@ public static _Fields findByThriftId(int fieldId) { return TABLENAME; case 5: // PARTITIONNAME return PARTITIONNAME; + case 6: // OPERATION_TYPE + return OPERATION_TYPE; + case 7: // IS_ACID + return IS_ACID; default: return null; } @@ -135,7 +149,9 @@ public String getFieldName() { } // isset id assignments - private static final _Fields optionals[] = {_Fields.TABLENAME,_Fields.PARTITIONNAME}; + private static final int __ISACID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.TABLENAME,_Fields.PARTITIONNAME,_Fields.OPERATION_TYPE,_Fields.IS_ACID}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); @@ -149,11 +165,19 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.PARTITIONNAME, new org.apache.thrift.meta_data.FieldMetaData("partitionname", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OPERATION_TYPE, new org.apache.thrift.meta_data.FieldMetaData("operationType", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DataOperationType.class))); + tmpMap.put(_Fields.IS_ACID, new org.apache.thrift.meta_data.FieldMetaData("isAcid", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(LockComponent.class, metaDataMap); } public LockComponent() { + this.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.UNSET; + + this.isAcid = false; + } public LockComponent( @@ -171,6 +195,7 @@ public LockComponent( * Performs a deep copy on other. */ public LockComponent(LockComponent other) { + __isset_bitfield = other.__isset_bitfield; if (other.isSetType()) { this.type = other.type; } @@ -186,6 +211,10 @@ public LockComponent(LockComponent other) { if (other.isSetPartitionname()) { this.partitionname = other.partitionname; } + if (other.isSetOperationType()) { + this.operationType = other.operationType; + } + this.isAcid = other.isAcid; } public LockComponent deepCopy() { @@ -199,6 +228,10 @@ public void clear() { this.dbname = null; this.tablename = null; this.partitionname = null; + this.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.UNSET; + + this.isAcid = false; + } /** @@ -332,6 +365,59 @@ public void setPartitionnameIsSet(boolean value) { } } + /** + * + * @see DataOperationType + */ + public DataOperationType getOperationType() { + return this.operationType; + } + + /** + * + * @see DataOperationType + */ + public void setOperationType(DataOperationType operationType) { + this.operationType = operationType; + } + + public void unsetOperationType() { + this.operationType = null; + } + + /** Returns true if field operationType is set (has been assigned a value) and false otherwise */ + public boolean isSetOperationType() { + return this.operationType != null; + } + + public void setOperationTypeIsSet(boolean value) { + if (!value) { + this.operationType = null; + } + } + + public boolean isIsAcid() { + return this.isAcid; + } + + public void setIsAcid(boolean isAcid) { + this.isAcid = isAcid; + setIsAcidIsSet(true); + } + + public void unsetIsAcid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISACID_ISSET_ID); + } + + /** Returns true if field isAcid is set (has been assigned a value) and false otherwise */ + public boolean isSetIsAcid() { + return EncodingUtils.testBit(__isset_bitfield, __ISACID_ISSET_ID); + } + + public void setIsAcidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISACID_ISSET_ID, value); + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TYPE: @@ -374,6 +460,22 @@ public void setFieldValue(_Fields field, Object value) { } break; + case OPERATION_TYPE: + if (value == null) { + unsetOperationType(); + } else { + setOperationType((DataOperationType)value); + } + break; + + case IS_ACID: + if (value == null) { + unsetIsAcid(); + } else { + setIsAcid((Boolean)value); + } + break; + } } @@ -394,6 +496,12 @@ public Object getFieldValue(_Fields field) { case PARTITIONNAME: return getPartitionname(); + case OPERATION_TYPE: + return getOperationType(); + + case IS_ACID: + return isIsAcid(); + } throw new IllegalStateException(); } @@ -415,6 +523,10 @@ public boolean isSet(_Fields field) { return isSetTablename(); case PARTITIONNAME: return isSetPartitionname(); + case OPERATION_TYPE: + return isSetOperationType(); + case IS_ACID: + return isSetIsAcid(); } throw new IllegalStateException(); } @@ -477,6 +589,24 @@ public boolean equals(LockComponent that) { return false; } + boolean this_present_operationType = true && this.isSetOperationType(); + boolean that_present_operationType = true && that.isSetOperationType(); + if (this_present_operationType || that_present_operationType) { + if (!(this_present_operationType && that_present_operationType)) + return false; + if (!this.operationType.equals(that.operationType)) + return false; + } + + boolean this_present_isAcid = true && this.isSetIsAcid(); + boolean that_present_isAcid = true && that.isSetIsAcid(); + if (this_present_isAcid || that_present_isAcid) { + if (!(this_present_isAcid && that_present_isAcid)) + return false; + if (this.isAcid != that.isAcid) + return false; + } + return true; } @@ -509,6 +639,16 @@ public int hashCode() { if (present_partitionname) list.add(partitionname); + boolean present_operationType = true && (isSetOperationType()); + list.add(present_operationType); + if (present_operationType) + list.add(operationType.getValue()); + + boolean present_isAcid = true && (isSetIsAcid()); + list.add(present_isAcid); + if (present_isAcid) + list.add(isAcid); + return list.hashCode(); } @@ -570,6 +710,26 @@ public int compareTo(LockComponent other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetOperationType()).compareTo(other.isSetOperationType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOperationType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.operationType, other.operationType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetIsAcid()).compareTo(other.isSetIsAcid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIsAcid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isAcid, other.isAcid); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -633,6 +793,22 @@ public String toString() { } first = false; } + if (isSetOperationType()) { + if (!first) sb.append(", "); + sb.append("operationType:"); + if (this.operationType == null) { + sb.append("null"); + } else { + sb.append(this.operationType); + } + first = false; + } + if (isSetIsAcid()) { + if (!first) sb.append(", "); + sb.append("isAcid:"); + sb.append(this.isAcid); + first = false; + } sb.append(")"); return sb.toString(); } @@ -664,6 +840,8 @@ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOExcept private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -728,6 +906,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, LockComponent struc org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 6: // OPERATION_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.findByValue(iprot.readI32()); + struct.setOperationTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // IS_ACID + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.isAcid = iprot.readBool(); + struct.setIsAcidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -770,6 +964,18 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, LockComponent stru oprot.writeFieldEnd(); } } + if (struct.operationType != null) { + if (struct.isSetOperationType()) { + oprot.writeFieldBegin(OPERATION_TYPE_FIELD_DESC); + oprot.writeI32(struct.operationType.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.isSetIsAcid()) { + oprot.writeFieldBegin(IS_ACID_FIELD_DESC); + oprot.writeBool(struct.isAcid); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -797,13 +1003,25 @@ public void write(org.apache.thrift.protocol.TProtocol prot, LockComponent struc if (struct.isSetPartitionname()) { optionals.set(1); } - oprot.writeBitSet(optionals, 2); + if (struct.isSetOperationType()) { + optionals.set(2); + } + if (struct.isSetIsAcid()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); if (struct.isSetTablename()) { oprot.writeString(struct.tablename); } if (struct.isSetPartitionname()) { oprot.writeString(struct.partitionname); } + if (struct.isSetOperationType()) { + oprot.writeI32(struct.operationType.getValue()); + } + if (struct.isSetIsAcid()) { + oprot.writeBool(struct.isAcid); + } } @Override @@ -815,7 +1033,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, LockComponent struct struct.setLevelIsSet(true); struct.dbname = iprot.readString(); struct.setDbnameIsSet(true); - BitSet incoming = iprot.readBitSet(2); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { struct.tablename = iprot.readString(); struct.setTablenameIsSet(true); @@ -824,6 +1042,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, LockComponent struct struct.partitionname = iprot.readString(); struct.setPartitionnameIsSet(true); } + if (incoming.get(2)) { + struct.operationType = org.apache.hadoop.hive.metastore.api.DataOperationType.findByValue(iprot.readI32()); + struct.setOperationTypeIsSet(true); + } + if (incoming.get(3)) { + struct.isAcid = iprot.readBool(); + struct.setIsAcidIsSet(true); + } } } diff --git metastore/src/gen/thrift/gen-php/metastore/Types.php metastore/src/gen/thrift/gen-php/metastore/Types.php index 189894d..5aef35c 100644 --- metastore/src/gen/thrift/gen-php/metastore/Types.php +++ metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -114,6 +114,23 @@ final class GrantRevokeType { ); } +final class DataOperationType { + const SELECT = 1; + const INSERT = 2; + const UPDATE = 3; + const DELETE = 4; + const UNSET = 5; + const NO_TXN = 6; + static public $__names = array( + 1 => 'SELECT', + 2 => 'INSERT', + 3 => 'UPDATE', + 4 => 'DELETE', + 5 => 'UNSET', + 6 => 'NO_TXN', + ); +} + final class EventRequestType { const INSERT = 1; const UPDATE = 2; @@ -12625,6 +12642,14 @@ class LockComponent { * @var string */ public $partitionname = null; + /** + * @var int + */ + public $operationType = 5; + /** + * @var bool + */ + public $isAcid = false; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -12649,6 +12674,14 @@ class LockComponent { 'var' => 'partitionname', 'type' => TType::STRING, ), + 6 => array( + 'var' => 'operationType', + 'type' => TType::I32, + ), + 7 => array( + 'var' => 'isAcid', + 'type' => TType::BOOL, + ), ); } if (is_array($vals)) { @@ -12667,6 +12700,12 @@ class LockComponent { if (isset($vals['partitionname'])) { $this->partitionname = $vals['partitionname']; } + if (isset($vals['operationType'])) { + $this->operationType = $vals['operationType']; + } + if (isset($vals['isAcid'])) { + $this->isAcid = $vals['isAcid']; + } } } @@ -12724,6 +12763,20 @@ class LockComponent { $xfer += $input->skip($ftype); } break; + case 6: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->operationType); + } else { + $xfer += $input->skip($ftype); + } + break; + case 7: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->isAcid); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -12762,6 +12815,16 @@ class LockComponent { $xfer += $output->writeString($this->partitionname); $xfer += $output->writeFieldEnd(); } + if ($this->operationType !== null) { + $xfer += $output->writeFieldBegin('operationType', TType::I32, 6); + $xfer += $output->writeI32($this->operationType); + $xfer += $output->writeFieldEnd(); + } + if ($this->isAcid !== null) { + $xfer += $output->writeFieldBegin('isAcid', TType::BOOL, 7); + $xfer += $output->writeBool($this->isAcid); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -14954,6 +15017,10 @@ class AddDynamicPartitions { * @var string[] */ public $partitionnames = null; + /** + * @var int + */ + public $operationType = 5; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -14978,6 +15045,10 @@ class AddDynamicPartitions { 'type' => TType::STRING, ), ), + 5 => array( + 'var' => 'operationType', + 'type' => TType::I32, + ), ); } if (is_array($vals)) { @@ -14993,6 +15064,9 @@ class AddDynamicPartitions { if (isset($vals['partitionnames'])) { $this->partitionnames = $vals['partitionnames']; } + if (isset($vals['operationType'])) { + $this->operationType = $vals['operationType']; + } } } @@ -15053,6 +15127,13 @@ class AddDynamicPartitions { $xfer += $input->skip($ftype); } break; + case 5: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->operationType); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -15098,6 +15179,11 @@ class AddDynamicPartitions { } $xfer += $output->writeFieldEnd(); } + if ($this->operationType !== null) { + $xfer += $output->writeFieldBegin('operationType', TType::I32, 5); + $xfer += $output->writeI32($this->operationType); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; diff --git metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index 6366a81..4db9680 100644 --- metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -168,6 +168,32 @@ class GrantRevokeType: "REVOKE": 2, } +class DataOperationType: + SELECT = 1 + INSERT = 2 + UPDATE = 3 + DELETE = 4 + UNSET = 5 + NO_TXN = 6 + + _VALUES_TO_NAMES = { + 1: "SELECT", + 2: "INSERT", + 3: "UPDATE", + 4: "DELETE", + 5: "UNSET", + 6: "NO_TXN", + } + + _NAMES_TO_VALUES = { + "SELECT": 1, + "INSERT": 2, + "UPDATE": 3, + "DELETE": 4, + "UNSET": 5, + "NO_TXN": 6, + } + class EventRequestType: INSERT = 1 UPDATE = 2 @@ -8725,6 +8751,8 @@ class LockComponent: - dbname - tablename - partitionname + - operationType + - isAcid """ thrift_spec = ( @@ -8734,14 +8762,18 @@ class LockComponent: (3, TType.STRING, 'dbname', None, None, ), # 3 (4, TType.STRING, 'tablename', None, None, ), # 4 (5, TType.STRING, 'partitionname', None, None, ), # 5 + (6, TType.I32, 'operationType', None, 5, ), # 6 + (7, TType.BOOL, 'isAcid', None, False, ), # 7 ) - def __init__(self, type=None, level=None, dbname=None, tablename=None, partitionname=None,): + def __init__(self, type=None, level=None, dbname=None, tablename=None, partitionname=None, operationType=thrift_spec[6][4], isAcid=thrift_spec[7][4],): self.type = type self.level = level self.dbname = dbname self.tablename = tablename self.partitionname = partitionname + self.operationType = operationType + self.isAcid = isAcid def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -8777,6 +8809,16 @@ def read(self, iprot): self.partitionname = iprot.readString() else: iprot.skip(ftype) + elif fid == 6: + if ftype == TType.I32: + self.operationType = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 7: + if ftype == TType.BOOL: + self.isAcid = iprot.readBool() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -8807,6 +8849,14 @@ def write(self, oprot): oprot.writeFieldBegin('partitionname', TType.STRING, 5) oprot.writeString(self.partitionname) oprot.writeFieldEnd() + if self.operationType is not None: + oprot.writeFieldBegin('operationType', TType.I32, 6) + oprot.writeI32(self.operationType) + oprot.writeFieldEnd() + if self.isAcid is not None: + oprot.writeFieldBegin('isAcid', TType.BOOL, 7) + oprot.writeBool(self.isAcid) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -8827,6 +8877,8 @@ def __hash__(self): value = (value * 31) ^ hash(self.dbname) value = (value * 31) ^ hash(self.tablename) value = (value * 31) ^ hash(self.partitionname) + value = (value * 31) ^ hash(self.operationType) + value = (value * 31) ^ hash(self.isAcid) return value def __repr__(self): @@ -10392,6 +10444,7 @@ class AddDynamicPartitions: - dbname - tablename - partitionnames + - operationType """ thrift_spec = ( @@ -10400,13 +10453,15 @@ class AddDynamicPartitions: (2, TType.STRING, 'dbname', None, None, ), # 2 (3, TType.STRING, 'tablename', None, None, ), # 3 (4, TType.LIST, 'partitionnames', (TType.STRING,None), None, ), # 4 + (5, TType.I32, 'operationType', None, 5, ), # 5 ) - def __init__(self, txnid=None, dbname=None, tablename=None, partitionnames=None,): + def __init__(self, txnid=None, dbname=None, tablename=None, partitionnames=None, operationType=thrift_spec[5][4],): self.txnid = txnid self.dbname = dbname self.tablename = tablename self.partitionnames = partitionnames + self.operationType = operationType def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -10442,6 +10497,11 @@ def read(self, iprot): iprot.readListEnd() else: iprot.skip(ftype) + elif fid == 5: + if ftype == TType.I32: + self.operationType = iprot.readI32() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -10471,6 +10531,10 @@ def write(self, oprot): oprot.writeString(iter475) oprot.writeListEnd() oprot.writeFieldEnd() + if self.operationType is not None: + oprot.writeFieldBegin('operationType', TType.I32, 5) + oprot.writeI32(self.operationType) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -10492,6 +10556,7 @@ def __hash__(self): value = (value * 31) ^ hash(self.dbname) value = (value * 31) ^ hash(self.tablename) value = (value * 31) ^ hash(self.partitionnames) + value = (value * 31) ^ hash(self.operationType) return value def __repr__(self): diff --git metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index e8d60d7..c7e7cb4 100644 --- metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -79,6 +79,17 @@ module GrantRevokeType VALID_VALUES = Set.new([GRANT, REVOKE]).freeze end +module DataOperationType + SELECT = 1 + INSERT = 2 + UPDATE = 3 + DELETE = 4 + UNSET = 5 + NO_TXN = 6 + VALUE_MAP = {1 => "SELECT", 2 => "INSERT", 3 => "UPDATE", 4 => "DELETE", 5 => "UNSET", 6 => "NO_TXN"} + VALID_VALUES = Set.new([SELECT, INSERT, UPDATE, DELETE, UNSET, NO_TXN]).freeze +end + module EventRequestType INSERT = 1 UPDATE = 2 @@ -1948,13 +1959,17 @@ class LockComponent DBNAME = 3 TABLENAME = 4 PARTITIONNAME = 5 + OPERATIONTYPE = 6 + ISACID = 7 FIELDS = { TYPE => {:type => ::Thrift::Types::I32, :name => 'type', :enum_class => ::LockType}, LEVEL => {:type => ::Thrift::Types::I32, :name => 'level', :enum_class => ::LockLevel}, DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbname'}, TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename', :optional => true}, - PARTITIONNAME => {:type => ::Thrift::Types::STRING, :name => 'partitionname', :optional => true} + PARTITIONNAME => {:type => ::Thrift::Types::STRING, :name => 'partitionname', :optional => true}, + OPERATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'operationType', :default => 5, :optional => true, :enum_class => ::DataOperationType}, + ISACID => {:type => ::Thrift::Types::BOOL, :name => 'isAcid', :default => false, :optional => true} } def struct_fields; FIELDS; end @@ -1969,6 +1984,9 @@ class LockComponent unless @level.nil? || ::LockLevel::VALID_VALUES.include?(@level) raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field level!') end + unless @operationType.nil? || ::DataOperationType::VALID_VALUES.include?(@operationType) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field operationType!') + end end ::Thrift::Struct.generate_accessors self @@ -2330,12 +2348,14 @@ class AddDynamicPartitions DBNAME = 2 TABLENAME = 3 PARTITIONNAMES = 4 + OPERATIONTYPE = 5 FIELDS = { TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'}, DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbname'}, TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'}, - PARTITIONNAMES => {:type => ::Thrift::Types::LIST, :name => 'partitionnames', :element => {:type => ::Thrift::Types::STRING}} + PARTITIONNAMES => {:type => ::Thrift::Types::LIST, :name => 'partitionnames', :element => {:type => ::Thrift::Types::STRING}}, + OPERATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'operationType', :default => 5, :optional => true, :enum_class => ::DataOperationType} } def struct_fields; FIELDS; end @@ -2345,6 +2365,9 @@ class AddDynamicPartitions raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field dbname is unset!') unless @dbname raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field tablename is unset!') unless @tablename raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field partitionnames is unset!') unless @partitionnames + unless @operationType.nil? || ::DataOperationType::VALID_VALUES.include?(@operationType) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field operationType!') + end end ::Thrift::Struct.generate_accessors self diff --git metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 2e83ee0..7d5ddee 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -46,6 +46,7 @@ import org.apache.hadoop.hive.metastore.api.CompactionType; import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.Database; import org.apache.hadoop.hive.metastore.api.DropConstraintRequest; import org.apache.hadoop.hive.metastore.api.DropPartitionsExpr; @@ -2161,10 +2162,18 @@ public ShowCompactResponse showCompactions() throws TException { return client.show_compact(new ShowCompactRequest()); } + @Deprecated @Override public void addDynamicPartitions(long txnId, String dbName, String tableName, List partNames) throws TException { client.add_dynamic_partitions(new AddDynamicPartitions(txnId, dbName, tableName, partNames)); + } + @Override + public void addDynamicPartitions(long txnId, String dbName, String tableName, + List partNames, DataOperationType operationType) throws TException { + AddDynamicPartitions adp = new AddDynamicPartitions(txnId, dbName, tableName, partNames); + adp.setOperationType(operationType); + client.add_dynamic_partitions(adp); } @InterfaceAudience.LimitedPrivate({"HCatalog"}) diff --git metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index f6ec596..06a1b58 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -32,6 +32,7 @@ import org.apache.hadoop.hive.metastore.api.CompactionType; import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.Database; import org.apache.hadoop.hive.metastore.api.EnvironmentContext; import org.apache.hadoop.hive.metastore.api.FieldSchema; @@ -1447,6 +1448,12 @@ void compact(String dbname, String tableName, String partitionName, CompactionT ShowCompactResponse showCompactions() throws TException; /** + * @deprecated in Hive 1.3.0/2.1.0 - will be removed in 2 releases + */ + @Deprecated + void addDynamicPartitions(long txnId, String dbName, String tableName, List partNames) + throws TException; + /** * Send a list of partitions to the metastore to indicate which partitions were loaded * dynamically. * @param txnId id of the transaction @@ -1455,7 +1462,8 @@ void compact(String dbname, String tableName, String partitionName, CompactionT * @param partNames partition name, as constructed by Warehouse.makePartName * @throws TException */ - void addDynamicPartitions(long txnId, String dbName, String tableName, List partNames) + void addDynamicPartitions(long txnId, String dbName, String tableName, List partNames, + DataOperationType operationType) throws TException; /** diff --git metastore/src/java/org/apache/hadoop/hive/metastore/LockComponentBuilder.java metastore/src/java/org/apache/hadoop/hive/metastore/LockComponentBuilder.java index acd4653..3e8f193 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/LockComponentBuilder.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/LockComponentBuilder.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.metastore; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockLevel; import org.apache.hadoop.hive.metastore.api.LockType; @@ -70,7 +71,16 @@ public LockComponentBuilder setDbName(String dbName) { component.setDbname(dbName); return this; } + + public LockComponentBuilder setOperationType(DataOperationType dop) { + component.setOperationType(dop); + return this; + } + public LockComponentBuilder setIsAcid(boolean t) { + component.setIsAcid(t); + return this; + } /** * Set the table name. * @param tableName table name diff --git metastore/src/java/org/apache/hadoop/hive/metastore/LockRequestBuilder.java metastore/src/java/org/apache/hadoop/hive/metastore/LockRequestBuilder.java index 2fa7e07..6317a96 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/LockRequestBuilder.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/LockRequestBuilder.java @@ -35,10 +35,19 @@ private LockTrie trie; private boolean userSet; + /** + * @deprecated + */ public LockRequestBuilder() { + this(null); + } + public LockRequestBuilder(String agentInfo) { req = new LockRequest(); trie = new LockTrie(); userSet = false; + if(agentInfo != null) { + req.setAgentInfo(agentInfo); + } } /** diff --git metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java index f061767..032e95d 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java @@ -128,7 +128,7 @@ static private boolean doRetryOnConnPool = false; private enum OpertaionType { - INSERT('i'), UPDATE('u'), DELETE('d'); + SELECT('s'), INSERT('i'), UPDATE('u'), DELETE('d'); private final char sqlConst; OpertaionType(char sqlConst) { this.sqlConst = sqlConst; @@ -138,6 +138,8 @@ public String toString() { } public static OpertaionType fromString(char sqlConst) { switch (sqlConst) { + case 's': + return SELECT; case 'i': return INSERT; case 'u': @@ -148,16 +150,18 @@ public static OpertaionType fromString(char sqlConst) { throw new IllegalArgumentException(quoteChar(sqlConst)); } } - //we should instead just pass in OpertaionType from client (HIVE-13622) - @Deprecated - public static OpertaionType fromLockType(LockType lockType) { - switch (lockType) { - case SHARED_READ: - return INSERT; - case SHARED_WRITE: - return UPDATE; + public static OpertaionType fromDataOperationType(DataOperationType dop) { + switch (dop) { + case SELECT: + return OpertaionType.SELECT; + case INSERT: + return OpertaionType.INSERT; + case UPDATE: + return OpertaionType.UPDATE; + case DELETE: + return OpertaionType.DELETE; default: - throw new IllegalArgumentException("Unexpected lock type: " + lockType); + throw new IllegalArgumentException("Unexpected value: " + dop); } } } @@ -652,20 +656,21 @@ public void commitTxn(CommitTxnRequest rqst) String s = "insert into COMPLETED_TXN_COMPONENTS select tc_txnid, tc_database, tc_table, " + "tc_partition from TXN_COMPONENTS where tc_txnid = " + txnid; LOG.debug("Going to execute insert <" + s + ">"); - if (stmt.executeUpdate(s) < 1) { + int modCount = 0; + if ((modCount = stmt.executeUpdate(s)) < 1) { //this can be reasonable for an empty txn START/COMMIT or read-only txn LOG.info("Expected to move at least one record from txn_components to " + "completed_txn_components when committing txn! " + JavaUtils.txnIdToString(txnid)); } s = "delete from TXN_COMPONENTS where tc_txnid = " + txnid; LOG.debug("Going to execute update <" + s + ">"); - stmt.executeUpdate(s); + modCount = stmt.executeUpdate(s); s = "delete from HIVE_LOCKS where hl_txnid = " + txnid; LOG.debug("Going to execute update <" + s + ">"); - stmt.executeUpdate(s); + modCount = stmt.executeUpdate(s); s = "delete from TXNS where txn_id = " + txnid; LOG.debug("Going to execute update <" + s + ">"); - stmt.executeUpdate(s); + modCount = stmt.executeUpdate(s); LOG.debug("Going to commit"); dbConn.commit(); } catch (SQLException e) { @@ -807,7 +812,7 @@ private ConnectionLockIdPair enqueueLockWithRetry(LockRequest rqst) throws NoSuc /** Get the next lock id. * This has to be atomic with adding entries to HIVE_LOCK entries (1st add in W state) to prevent a race. * Suppose ID gen is a separate txn and 2 concurrent lock() methods are running. 1st one generates nl_next=7, - * 2nd nl_next=8. Then 8 goes first to insert into HIVE_LOCKS and aquires the locks. Then 7 unblocks, + * 2nd nl_next=8. Then 8 goes first to insert into HIVE_LOCKS and acquires the locks. Then 7 unblocks, * and add it's W locks but it won't see locks from 8 since to be 'fair' {@link #checkLock(java.sql.Connection, long)} * doesn't block on locks acquired later than one it's checking*/ String s = addForUpdateClause("select nl_next from NEXT_LOCK_ID"); @@ -825,13 +830,8 @@ private ConnectionLockIdPair enqueueLockWithRetry(LockRequest rqst) throws NoSuc stmt.executeUpdate(s); if (txnid > 0) { - /**DBTxnManager#acquireLocks() knows if it's I/U/D (that's how it decides what lock to get) - * So if we add that to LockRequest we'll know that here - * Should probably add it to LockComponent so that if in the future we decide wo allow 1 LockRequest - * to contain LockComponent for multiple operations. - * Deriving it from lock info doesn't distinguish between Update and Delete - * - * QueryPlan has BaseSemanticAnalyzer which has acidFileSinks list of FileSinkDesc + /** + * todo QueryPlan has BaseSemanticAnalyzer which has acidFileSinks list of FileSinkDesc * FileSinkDesc.table is ql.metadata.Table * Table.tableSpec which is TableSpec, which has specType which is SpecType * So maybe this can work to know that this is part of dynamic partition insert in which case @@ -840,8 +840,35 @@ private ConnectionLockIdPair enqueueLockWithRetry(LockRequest rqst) throws NoSuc */ // For each component in this lock request, // add an entry to the txn_components table - // This must be done before HIVE_LOCKS is accessed for (LockComponent lc : rqst.getComponent()) { + if(lc.isSetIsAcid() && !lc.isIsAcid()) { + //we don't prevent using non-acid resources in a txn but we do lock them + continue; + } + boolean updateTxnComponents; + if(!lc.isSetOperationType()) { + //request came from old version of the client + updateTxnComponents = true;//this matches old behavior + } + else { + switch (lc.getOperationType()) { + case INSERT: + case UPDATE: + case DELETE: + updateTxnComponents = true; + break; + case SELECT: + updateTxnComponents = false; + break; + default: + //since we have an open transaction, only 4 values above are expected + throw new IllegalStateException("Unexpected DataOperationType: " + lc.getOperationType() + + " agentInfo=" + rqst.getAgentInfo() + " " + JavaUtils.txnIdToString(txnid)); + } + } + if(!updateTxnComponents) { + continue; + } String dbName = lc.getDbname(); String tblName = lc.getTablename(); String partName = lc.getPartitionname(); @@ -850,14 +877,19 @@ private ConnectionLockIdPair enqueueLockWithRetry(LockRequest rqst) throws NoSuc "values (" + txnid + ", '" + dbName + "', " + (tblName == null ? "null" : "'" + tblName + "'") + ", " + (partName == null ? "null" : "'" + partName + "'")+ "," + - quoteString(OpertaionType.fromLockType(lc.getType()).toString()) + ")"; + quoteString(OpertaionType.fromDataOperationType(lc.getOperationType()).toString()) + ")"; LOG.debug("Going to execute update <" + s + ">"); - stmt.executeUpdate(s); + int modCount = stmt.executeUpdate(s); } } long intLockId = 0; for (LockComponent lc : rqst.getComponent()) { + if(lc.isSetOperationType() && lc.getOperationType() == DataOperationType.UNSET) { + //old version of thrift client should have (lc.isSetOperationType() == false) + throw new IllegalStateException("Bug: operationType=" + lc.getOperationType() + " for component " + + lc + " agentInfo=" + rqst.getAgentInfo()); + } intLockId++; String dbName = lc.getDbname(); String tblName = lc.getTablename(); @@ -1429,21 +1461,13 @@ public void addDynamicPartitions(AddDynamicPartitions rqst) ensureValidTxn(dbConn, rqst.getTxnid(), stmt); shouldNeverHappen(rqst.getTxnid()); } - //we should be able to get this from AddDynamicPartitions object longer term; in fact we'd have to - //for multi stmt txns if same table is written more than once per tx - // MoveTask knows if it's I/U/D - // MoveTask calls Hive.loadDynamicPartitions() which calls HiveMetaStoreClient.addDynamicPartitions() - // which ends up here so we'd need to add a field to AddDynamicPartitions. - String findOperationType = " tc_operation_type from TXN_COMPONENTS where tc_txnid=" + rqst.getTxnid() - + " and tc_database=" + quoteString(rqst.getDbname()) + " and tc_table=" + quoteString(rqst.getTablename()); - //do limit 1 on this; currently they will all have the same operations - rs = stmt.executeQuery(addLimitClause(1, findOperationType)); - if(!rs.next()) { - throw new IllegalStateException("Unable to determine tc_operation_type for " + JavaUtils.txnIdToString(rqst.getTxnid())); + //for RU this may be null so we should default it to 'u' which is most restrictive + OpertaionType ot = OpertaionType.UPDATE; + if(rqst.isSetOperationType()) { + ot = OpertaionType.fromDataOperationType(rqst.getOperationType()); } - OpertaionType ot = OpertaionType.fromString(rs.getString(1).charAt(0)); - //what if a txn writes the same table > 1 time... let's go with this for now, but really + //what if a txn writes the same table > 1 time...(HIVE-9675) let's go with this for now, but really //need to not write this in the first place, i.e. make this delete not needed //see enqueueLockWithRetry() - that's where we write to TXN_COMPONENTS String deleteSql = "delete from TXN_COMPONENTS where tc_txnid=" + rqst.getTxnid() + " and tc_database=" + @@ -1452,14 +1476,14 @@ public void addDynamicPartitions(AddDynamicPartitions rqst) //much "wider" than necessary in a lot of cases. Here on the other hand, we know exactly which //partitions have been written to. w/o this WRITE_SET would contain entries for partitions not actually //written to - stmt.executeUpdate(deleteSql); + int modCount = stmt.executeUpdate(deleteSql); for (String partName : rqst.getPartitionnames()) { String s = "insert into TXN_COMPONENTS (tc_txnid, tc_database, tc_table, tc_partition, tc_operation_type) values (" + rqst.getTxnid() + "," + quoteString(rqst.getDbname()) + "," + quoteString(rqst.getTablename()) + "," + quoteString(partName) + "," + quoteChar(ot.sqlConst) + ")"; LOG.debug("Going to execute update <" + s + ">"); - stmt.executeUpdate(s); + modCount = stmt.executeUpdate(s); } LOG.debug("Going to commit"); dbConn.commit(); @@ -1479,8 +1503,8 @@ public void addDynamicPartitions(AddDynamicPartitions rqst) } /** - * Clean up corresponding records in metastore tables, specifically: - * TXN_COMPONENTS, COMPLETED_TXN_COMPONENTS, COMPACTION_QUEUE, COMPLETED_COMPACTIONS + * Clean up corresponding records in metastore tables when corresponding object is dropped, + * specifically: TXN_COMPONENTS, COMPLETED_TXN_COMPONENTS, COMPACTION_QUEUE, COMPLETED_COMPACTIONS */ public void cleanupRecords(HiveObjectType type, Database db, Table table, Iterator partitionIterator) throws MetaException { diff --git metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestCompactionTxnHandler.java metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestCompactionTxnHandler.java index 80e3cd6..f513d0f 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestCompactionTxnHandler.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestCompactionTxnHandler.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; import org.apache.hadoop.hive.metastore.api.CompactionRequest; import org.apache.hadoop.hive.metastore.api.CompactionType; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockLevel; @@ -286,12 +287,14 @@ public void testFindPotentialCompactions() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("yourtable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.UPDATE); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); req.setTxnid(txnid); @@ -322,6 +325,7 @@ public void testMarkCleanedCleansTxnsAndTxnComponents() LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.INSERT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -333,6 +337,7 @@ public void testMarkCleanedCleansTxnsAndTxnComponents() txnid = openTxn(); comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("yourtable"); + comp.setOperationType(DataOperationType.DELETE); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -345,6 +350,7 @@ public void testMarkCleanedCleansTxnsAndTxnComponents() comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("foo"); comp.setPartitionname("bar"); + comp.setOperationType(DataOperationType.UPDATE); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -355,6 +361,7 @@ public void testMarkCleanedCleansTxnsAndTxnComponents() comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("foo"); comp.setPartitionname("baz"); + comp.setOperationType(DataOperationType.UPDATE); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -411,13 +418,17 @@ public void addDynamicPartitions() throws Exception { // lock a table, as in dynamic partitions LockComponent lc = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, dbName); lc.setTablename(tableName); + DataOperationType dop = DataOperationType.UPDATE; + lc.setOperationType(dop); LockRequest lr = new LockRequest(Arrays.asList(lc), "me", "localhost"); lr.setTxnid(txnId); LockResponse lock = txnHandler.lock(lr); assertEquals(LockState.ACQUIRED, lock.getState()); - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnId, dbName, tableName, - Arrays.asList("ds=yesterday", "ds=today"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnId, dbName, tableName, + Arrays.asList("ds=yesterday", "ds=today")); + adp.setOperationType(dop); + txnHandler.addDynamicPartitions(adp); txnHandler.commitTxn(new CommitTxnRequest(txnId)); Set potentials = txnHandler.findPotentialCompactions(1000); diff --git metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestTxnHandler.java metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestTxnHandler.java index 1a118a9..2804e21 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestTxnHandler.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestTxnHandler.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; import org.apache.hadoop.hive.metastore.api.CompactionRequest; import org.apache.hadoop.hive.metastore.api.CompactionType; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.GetOpenTxnsInfoResponse; import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.HeartbeatRequest; @@ -216,6 +217,7 @@ public void testValidTxnsSomeOpen() throws Exception { public void testLockDifferentDBs() throws Exception { // Test that two different databases don't collide on their locks LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -223,6 +225,7 @@ public void testLockDifferentDBs() throws Exception { assertTrue(res.getState() == LockState.ACQUIRED); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "yourdb"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -234,6 +237,7 @@ public void testLockDifferentDBs() throws Exception { public void testLockSameDB() throws Exception { // Test that two different databases don't collide on their locks LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -241,6 +245,7 @@ public void testLockSameDB() throws Exception { assertTrue(res.getState() == LockState.ACQUIRED); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -252,6 +257,7 @@ public void testLockSameDB() throws Exception { public void testLockDbLocksTable() throws Exception { // Test that locking a database prevents locking of tables in the database LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -259,6 +265,7 @@ public void testLockDbLocksTable() throws Exception { assertTrue(res.getState() == LockState.ACQUIRED); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); comp.setTablename("mytable"); components.clear(); components.add(comp); @@ -271,6 +278,7 @@ public void testLockDbLocksTable() throws Exception { public void testLockDbDoesNotLockTableInDifferentDB() throws Exception { // Test that locking a database prevents locking of tables in the database LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -278,6 +286,7 @@ public void testLockDbDoesNotLockTableInDifferentDB() throws Exception { assertTrue(res.getState() == LockState.ACQUIRED); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "yourdb"); + comp.setOperationType(DataOperationType.NO_TXN); comp.setTablename("mytable"); components.clear(); components.add(comp); @@ -290,6 +299,7 @@ public void testLockDbDoesNotLockTableInDifferentDB() throws Exception { public void testLockDifferentTables() throws Exception { // Test that two different tables don't collide on their locks LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); comp.setTablename("mytable"); List components = new ArrayList(1); components.add(comp); @@ -298,6 +308,7 @@ public void testLockDifferentTables() throws Exception { assertTrue(res.getState() == LockState.ACQUIRED); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); comp.setTablename("yourtable"); components.clear(); components.add(comp); @@ -311,6 +322,7 @@ public void testLockSameTable() throws Exception { // Test that two different tables don't collide on their locks LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -319,6 +331,7 @@ public void testLockSameTable() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -331,6 +344,7 @@ public void testLockTableLocksPartition() throws Exception { // Test that locking a table prevents locking of partitions of the table LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -340,6 +354,7 @@ public void testLockTableLocksPartition() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -352,6 +367,7 @@ public void testLockDifferentTableDoesntLockPartition() throws Exception { // Test that locking a table prevents locking of partitions of the table LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -361,6 +377,7 @@ public void testLockDifferentTableDoesntLockPartition() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("yourtable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -374,6 +391,7 @@ public void testLockDifferentPartitions() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -383,6 +401,7 @@ public void testLockDifferentPartitions() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("yourpartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -396,6 +415,7 @@ public void testLockSamePartition() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -405,6 +425,7 @@ public void testLockSamePartition() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -418,6 +439,7 @@ public void testLockSRSR() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.INSERT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -427,6 +449,7 @@ public void testLockSRSR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -440,6 +463,7 @@ public void testLockESRSR() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -449,6 +473,7 @@ public void testLockESRSR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.INSERT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -458,6 +483,7 @@ public void testLockESRSR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -471,6 +497,7 @@ public void testLockSRSW() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.INSERT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -480,6 +507,7 @@ public void testLockSRSW() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -494,6 +522,7 @@ public void testLockESRSW() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -503,6 +532,7 @@ public void testLockESRSW() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -512,6 +542,7 @@ public void testLockESRSW() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.UPDATE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -526,6 +557,7 @@ public void testLockSRE() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -535,6 +567,7 @@ public void testLockSRE() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -548,6 +581,7 @@ public void testLockESRE() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -557,6 +591,7 @@ public void testLockESRE() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -566,6 +601,7 @@ public void testLockESRE() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -579,6 +615,7 @@ public void testLockSWSR() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -589,6 +626,7 @@ public void testLockSWSR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -602,6 +640,7 @@ public void testLockSWSWSR() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -612,6 +651,7 @@ public void testLockSWSWSR() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -622,6 +662,7 @@ public void testLockSWSWSR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.INSERT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -630,11 +671,31 @@ public void testLockSWSWSR() throws Exception { } @Test + public void testWrongLockForOperation() throws Exception { + LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); + comp.setTablename("mytable"); + comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); + List components = new ArrayList(1); + components.add(comp); + LockRequest req = new LockRequest(components, "me", "localhost"); + req.setTxnid(openTxn()); + Exception expectedError = null; + try { + LockResponse res = txnHandler.lock(req); + } + catch(Exception e) { + expectedError = e; + } + Assert.assertTrue(expectedError != null && expectedError.getMessage().contains("Unexpected DataOperationType")); + } + @Test public void testLockSWSWSW() throws Exception { // Test that write blocks two writes LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -645,6 +706,7 @@ public void testLockSWSWSW() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -655,6 +717,7 @@ public void testLockSWSWSW() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -669,6 +732,7 @@ public void testLockEESW() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -678,6 +742,7 @@ public void testLockEESW() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -687,6 +752,7 @@ public void testLockEESW() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -701,6 +767,7 @@ public void testLockEESR() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -710,6 +777,7 @@ public void testLockEESR() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -719,6 +787,7 @@ public void testLockEESR() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.SELECT); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -731,6 +800,7 @@ public void testCheckLockAcquireAfterWaiting() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -743,6 +813,7 @@ public void testCheckLockAcquireAfterWaiting() throws Exception { comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.UPDATE); components.clear(); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -772,6 +843,7 @@ public void testCheckLockTxnAborted() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -794,12 +866,14 @@ public void testMultipleLock() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(2); components.add(comp); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("anotherpartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); LockResponse res = txnHandler.lock(req); @@ -817,12 +891,14 @@ public void testMultipleLockWait() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(2); components.add(comp); comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("anotherpartition"); + comp.setOperationType(DataOperationType.NO_TXN); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); LockResponse res = txnHandler.lock(req); @@ -833,6 +909,7 @@ public void testMultipleLockWait() throws Exception { comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -852,6 +929,7 @@ public void testUnlockOnCommit() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -867,6 +945,7 @@ public void testUnlockOnAbort() throws Exception { // Test that committing unlocks long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -886,6 +965,7 @@ public void testUnlockWithTxn() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -932,6 +1012,7 @@ public void testHeartbeatLock() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -996,6 +1077,7 @@ public void testLockTimeout() throws Exception { LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); comp.setTablename("mytable"); comp.setPartitionname("mypartition"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -1083,6 +1165,7 @@ public void testCompactMinorNoPartition() throws Exception { public void showLocks() throws Exception { long begining = System.currentTimeMillis(); LockComponent comp = new LockComponent(LockType.EXCLUSIVE, LockLevel.DB, "mydb"); + comp.setOperationType(DataOperationType.NO_TXN); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -1092,6 +1175,7 @@ public void showLocks() throws Exception { long txnid = openTxn(); comp = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "mydb"); comp.setTablename("mytable"); + comp.setOperationType(DataOperationType.SELECT); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -1103,6 +1187,7 @@ public void showLocks() throws Exception { comp = new LockComponent(LockType.SHARED_READ, LockLevel.PARTITION, "yourdb"); comp.setTablename("yourtable"); comp.setPartitionname("yourpartition"); + comp.setOperationType(DataOperationType.INSERT); components.add(comp); req = new LockRequest(components, "you", "remotehost"); res = txnHandler.lock(req); diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java index 21aa315..aeaae6b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java @@ -429,7 +429,8 @@ public int execute(DriverContext driverContext) { dpCtx.getNumDPCols(), isSkewedStoredAsDirs(tbd), work.getLoadTableWork().getWriteType() != AcidUtils.Operation.NOT_ACID, - SessionState.get().getTxnMgr().getCurrentTxnId(), hasFollowingStatsTask()); + SessionState.get().getTxnMgr().getCurrentTxnId(), hasFollowingStatsTask(), + work.getLoadTableWork().getWriteType()); console.printInfo("\t Time taken to load dynamic partitions: " + (System.currentTimeMillis() - startTime)/1000.0 + " seconds"); diff --git ql/src/java/org/apache/hadoop/hive/ql/io/AcidUtils.java ql/src/java/org/apache/hadoop/hive/ql/io/AcidUtils.java index 9446876..bac38ce 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/AcidUtils.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/AcidUtils.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.io; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.conf.Configuration; @@ -221,7 +222,20 @@ static long parseBase(Path path) { return result; } - public enum Operation { NOT_ACID, INSERT, UPDATE, DELETE } + public enum Operation { + NOT_ACID(DataOperationType.UNSET), + INSERT(DataOperationType.INSERT), + UPDATE(DataOperationType.UPDATE), + DELETE(DataOperationType.DELETE); + + private final DataOperationType dop; + private Operation(DataOperationType dop) { + this.dop = dop; + } + public DataOperationType toDataOperationType() { + return dop; + } + } public static interface Directory { diff --git ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java index 9ab6169..9988eec 100644 --- ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java +++ ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java @@ -162,7 +162,7 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB boolean atLeastOneLock = false; - LockRequestBuilder rqstBuilder = new LockRequestBuilder(); + LockRequestBuilder rqstBuilder = new LockRequestBuilder(plan.getQueryId()); //link queryId to txnId LOG.info("Setting lock request transaction to " + JavaUtils.txnIdToString(txnId) + " for queryId=" + plan.getQueryId()); rqstBuilder.setTransactionId(txnId) @@ -178,6 +178,7 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB } LockComponentBuilder compBuilder = new LockComponentBuilder(); compBuilder.setShared(); + compBuilder.setOperationType(DataOperationType.SELECT); Table t = null; switch (input.getType()) { @@ -203,6 +204,9 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB // This is a file or something we don't hold locks for. continue; } + if(t != null && AcidUtils.isAcidTable(t)) { + compBuilder.setIsAcid(true); + } LockComponent comp = compBuilder.build(); LOG.debug("Adding lock component to lock request " + comp.toString()); rqstBuilder.addLockComponent(comp); @@ -226,27 +230,35 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB case DDL_EXCLUSIVE: case INSERT_OVERWRITE: compBuilder.setExclusive(); + compBuilder.setOperationType(DataOperationType.NO_TXN); break; case INSERT: - t = output.getTable(); - if(t == null) { - throw new IllegalStateException("No table info for " + output); - } + t = getTable(output); if(AcidUtils.isAcidTable(t)) { compBuilder.setShared(); + compBuilder.setIsAcid(true); } else { compBuilder.setExclusive(); + compBuilder.setIsAcid(false); } + compBuilder.setOperationType(DataOperationType.INSERT); break; case DDL_SHARED: compBuilder.setShared(); + compBuilder.setOperationType(DataOperationType.NO_TXN); break; case UPDATE: + compBuilder.setSemiShared(); + compBuilder.setOperationType(DataOperationType.UPDATE); + t = getTable(output); + break; case DELETE: compBuilder.setSemiShared(); + compBuilder.setOperationType(DataOperationType.DELETE); + t = getTable(output); break; case DDL_NO_LOCK: @@ -280,12 +292,15 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB // This is a file or something we don't hold locks for. continue; } + if(t != null && AcidUtils.isAcidTable(t)) { + compBuilder.setIsAcid(true); + } LockComponent comp = compBuilder.build(); LOG.debug("Adding lock component to lock request " + comp.toString()); rqstBuilder.addLockComponent(comp); atLeastOneLock = true; } - + //plan // Make sure we need locks. It's possible there's nothing to lock in // this operation. if (!atLeastOneLock) { @@ -301,6 +316,13 @@ LockState acquireLocks(QueryPlan plan, Context ctx, String username, boolean isB ctx.setHiveLocks(locks); return lockState; } + private static Table getTable(WriteEntity we) { + Table t = we.getTable(); + if(t == null) { + throw new IllegalStateException("No table info for " + we); + } + return t; + } /** * This is for testing only. * @param delay time to delay for first heartbeat diff --git ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java index dcfc2b5..3fa1233 100644 --- ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -1695,7 +1695,8 @@ private void constructOneLBLocationMap(FileStatus fSta, */ public Map, Partition> loadDynamicPartitions(Path loadPath, String tableName, Map partSpec, boolean replace, - int numDP, boolean listBucketingEnabled, boolean isAcid, long txnId, boolean hasFollowingStatsTask) + int numDP, boolean listBucketingEnabled, boolean isAcid, long txnId, boolean hasFollowingStatsTask, + AcidUtils.Operation operation) throws HiveException { Set validPartitions = new HashSet(); @@ -1758,7 +1759,8 @@ private void constructOneLBLocationMap(FileStatus fSta, for (Partition p : partitionsMap.values()) { partNames.add(p.getName()); } - metaStoreClient.addDynamicPartitions(txnId, tbl.getDbName(), tbl.getTableName(), partNames); + metaStoreClient.addDynamicPartitions(txnId, tbl.getDbName(), tbl.getTableName(), + partNames, operation.toDataOperationType()); } return partitionsMap; } catch (IOException e) { diff --git ql/src/test/org/apache/hadoop/hive/ql/lockmgr/TestDbTxnManager2.java ql/src/test/org/apache/hadoop/hive/ql/lockmgr/TestDbTxnManager2.java index 8840fd9..4782213 100644 --- ql/src/test/org/apache/hadoop/hive/ql/lockmgr/TestDbTxnManager2.java +++ ql/src/test/org/apache/hadoop/hive/ql/lockmgr/TestDbTxnManager2.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.lockmgr; import org.apache.hadoop.hive.metastore.api.AddDynamicPartitions; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.txn.TxnStore; import org.apache.hadoop.hive.metastore.txn.TxnUtils; import org.apache.hadoop.hive.ql.TestTxnCommands2; @@ -866,8 +867,10 @@ public void testWriteSetTracking4() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB2", null, locks.get(1)); //update stmt has p=blah, thus nothing is actually update and we generate empty dyn part list Assert.assertEquals(0, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET")); - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), - "default", "tab2", Collections.EMPTY_LIST)); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), + "default", "tab2", Collections.EMPTY_LIST); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn(); //Short Running updated nothing, so we expect 0 rows in WRITE_SET Assert.assertEquals( 0, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET")); @@ -881,8 +884,10 @@ public void testWriteSetTracking4() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB2", null, locks.get(1));//since TAB2 is empty //update stmt has p=blah, thus nothing is actually update and we generate empty dyn part list Assert.assertEquals(0, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET")); - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), - "default", "tab2", Collections.singletonList("p=two")));//simulate partition update + adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), + "default", "tab2", Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp);//simulate partition update txnMgr2.commitTxn(); Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET")); @@ -894,8 +899,10 @@ public void testWriteSetTracking4() throws Exception { checkCmdOnDriver(driver.compileAndRespond("update TAB2 set b = 17 where a = 1"));//no rows match txnMgr.acquireLocks(driver.getPlan(), ctx, "Long Running"); //so generate empty Dyn Part call - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), - "default", "tab2", Collections.EMPTY_LIST)); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), + "default", "tab2", Collections.EMPTY_LIST); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr.commitTxn(); locks = getLocks(txnMgr); @@ -996,16 +1003,20 @@ public void testWriteSetTracking7() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB2", "p=one", locks.get(1)); //this simulates the completion of txnid:2 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab2", - Collections.singletonList("p=two"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab2", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:2 locks = getLocks(txnMgr2); Assert.assertEquals("Unexpected lock count", 1, locks.size()); checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB2", "p=one", locks.get(0)); //completion of txnid:3 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab2", - Collections.singletonList("p=one"))); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab2", + Collections.singletonList("p=one")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr.commitTxn();//txnid:3 //now both txns concurrently updated TAB2 but different partitions. @@ -1043,8 +1054,10 @@ public void testWriteSetTracking7() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=one", locks.get(3)); //this simulates the completion of txnid:5 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=one"))); + adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=one")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:5 ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(2).getLockid());//retest WAITING locks (both have same ext id) @@ -1053,8 +1066,10 @@ public void testWriteSetTracking7() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=one", locks.get(1)); //completion of txnid:6 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr.commitTxn();//txnid:6 Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), @@ -1094,8 +1109,10 @@ public void testWriteSetTracking8() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=two", locks.get(2)); //this simulates the completion of txnid:2 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=one"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=one")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:2 ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(2).getLockid());//retest WAITING locks (both have same ext id) @@ -1103,8 +1120,10 @@ public void testWriteSetTracking8() throws Exception { Assert.assertEquals("Unexpected lock count", 1, locks.size()); checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); //completion of txnid:3 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr.commitTxn();//txnid:3 Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), @@ -1143,8 +1162,10 @@ public void testWriteSetTracking9() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=two", locks.get(2)); //this simulates the completion of txnid:2 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=one"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=one")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:2 ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(2).getLockid());//retest WAITING locks (both have same ext id) @@ -1152,14 +1173,22 @@ public void testWriteSetTracking9() throws Exception { Assert.assertEquals("Unexpected lock count", 1, locks.size()); checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); //completion of txnid:3 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.DELETE); + txnHandler.addDynamicPartitions(adp); txnMgr.commitTxn();//txnid:3 + Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 2, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=1 and ctc_table='tab1'")); + Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 1, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=2 and ctc_table='tab1' and ctc_partition='p=one'")); + Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 1, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=3 and ctc_table='tab1' and ctc_partition='p=two'")); Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=one' and ws_operation_type='u' and ws_table='tab1'")); Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), - 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='u' and ws_table='tab1'")); + 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1'")); Assert.assertEquals("COMPLETED_TXN_COMPONENTS mismatch: " + TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), 4, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_table='tab1' and ctc_partition is not null")); } @@ -1192,8 +1221,10 @@ public void testWriteSetTracking10() throws Exception { checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=two", locks.get(2)); //this simulates the completion of txnid:2 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.UPDATE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:2 ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(2).getLockid());//retest WAITING locks (both have same ext id) @@ -1201,8 +1232,10 @@ public void testWriteSetTracking10() throws Exception { Assert.assertEquals("Unexpected lock count", 1, locks.size()); checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); //completion of txnid:3 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.DELETE); + txnHandler.addDynamicPartitions(adp); LockException exception = null; try { txnMgr.commitTxn();//txnid:3 @@ -1222,11 +1255,7 @@ public void testWriteSetTracking10() throws Exception { } /** * Concurrent delte/detele of same partition - should pass - * This test doesn't work yet, because we don't yet pass in operation type - * - * todo: Concurrent insert/update of same partition - should pass */ - @Ignore("HIVE-13622") @Test public void testWriteSetTracking11() throws Exception { CommandProcessorResponse cpr = driver.run("create table if not exists tab1 (a int, b int) partitioned by (p string) " + @@ -1244,46 +1273,86 @@ public void testWriteSetTracking11() throws Exception { //now start concurrent txn txnMgr.openTxn("T3"); + checkCmdOnDriver(driver.compileAndRespond("select * from tab1 where b=1 and p='one'")); + ((DbTxnManager)txnMgr).acquireLocks(driver.getPlan(), ctx, "T3", false); checkCmdOnDriver(driver.compileAndRespond("delete from tab1 where p='two' and b=2")); ((DbTxnManager)txnMgr).acquireLocks(driver.getPlan(), ctx, "T3", false); locks = getLocks(txnMgr); - Assert.assertEquals("Unexpected lock count", 3, locks.size()); - checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); - checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=one", locks.get(1)); - checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=two", locks.get(2)); + Assert.assertEquals("Unexpected lock count", 5, locks.size()); + checkLock(LockType.SHARED_READ, LockState.ACQUIRED, "default", "TAB1", null, locks.get(0)); + checkLock(LockType.SHARED_READ, LockState.ACQUIRED, "default", "TAB1", "p=one", locks.get(1)); + checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(2)); + checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=one", locks.get(3)); + checkLock(LockType.SHARED_WRITE, LockState.WAITING, "default", "TAB1", "p=two", locks.get(4)); //this simulates the completion of txnid:2 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); + AddDynamicPartitions adp = new AddDynamicPartitions(txnMgr2.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.DELETE); + txnHandler.addDynamicPartitions(adp); txnMgr2.commitTxn();//txnid:2 - ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(2).getLockid());//retest WAITING locks (both have same ext id) + ((DbLockManager)txnMgr.getLockManager()).checkLock(locks.get(4).getLockid());//retest WAITING locks (both have same ext id) locks = getLocks(txnMgr); - Assert.assertEquals("Unexpected lock count", 1, locks.size()); - checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(0)); + Assert.assertEquals("Unexpected lock count", 3, locks.size()); + checkLock(LockType.SHARED_READ, LockState.ACQUIRED, "default", "TAB1", null, locks.get(0)); + checkLock(LockType.SHARED_READ, LockState.ACQUIRED, "default", "TAB1", "p=one", locks.get(1)); + checkLock(LockType.SHARED_WRITE, LockState.ACQUIRED, "default", "TAB1", "p=two", locks.get(2)); //completion of txnid:3 - txnHandler.addDynamicPartitions(new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", - Collections.singletonList("p=two"))); - LockException exception = null; - try { - txnMgr.commitTxn();//txnid:3 - } - catch(LockException e) { - exception = e; - } - Assert.assertNotEquals("Expected exception", null, exception); - Assert.assertEquals("Exception msg doesn't match", - "Aborting [txnid:3,3] due to a write conflict on default/tab1/p=two committed by [txnid:2,3]", - exception.getCause().getMessage()); + adp = new AddDynamicPartitions(txnMgr.getCurrentTxnId(), "default", "tab1", + Collections.singletonList("p=two")); + adp.setOperationType(DataOperationType.DELETE); + txnHandler.addDynamicPartitions(adp); + txnMgr.commitTxn();//txnid:3 - //todo: this currently fails since we don't yet set operation type properly Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), - 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1'")); + 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1' and ws_txnid=2")); Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), - 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1'")); + 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1' and ws_txnid=3")); + Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), + 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1' and ws_txnid=2")); + Assert.assertEquals("WRITE_SET mismatch: " + TxnDbUtil.queryToString("select * from WRITE_SET"), + 1, TxnDbUtil.countQueryAgent("select count(*) from WRITE_SET where ws_partition='p=two' and ws_operation_type='d' and ws_table='tab1' and ws_txnid=3")); Assert.assertEquals("COMPLETED_TXN_COMPONENTS mismatch: " + TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), 4, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_table='tab1' and ctc_partition is not null")); } + @Test + public void testCompletedTxnComponents() throws Exception { + CommandProcessorResponse cpr = driver.run("create table if not exists tab1 (a int, b int) partitioned by (p string) " + + "clustered by (a) into 2 buckets stored as orc TBLPROPERTIES ('transactional'='true')"); + checkCmdOnDriver(cpr); + cpr = driver.run("create table if not exists tab_not_acid2 (a int, b int)"); + checkCmdOnDriver(cpr); + checkCmdOnDriver(driver.run("insert into tab_not_acid2 values(1,1),(2,2)")); + //writing both acid and non-acid resources in the same txn + checkCmdOnDriver(driver.run("from tab_not_acid2 insert into tab1 partition(p='two')(a,b) select a,b insert into tab_not_acid2(a,b) select a,b "));//txnid:1 + Assert.assertEquals(TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 1, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS")); + //only expect transactional components to be in COMPLETED_TXN_COMPONENTS + Assert.assertEquals(TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 1, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=1 and ctc_table='tab1'")); + } + @Test + public void testMultiInsert() throws Exception { + CommandProcessorResponse cpr = driver.run("create table if not exists tab1 (a int, b int) partitioned by (p string) " + + "clustered by (a) into 2 buckets stored as orc TBLPROPERTIES ('transactional'='true')"); + checkCmdOnDriver(cpr); + cpr = driver.run("create table if not exists tab_not_acid (a int, b int, p string)"); + checkCmdOnDriver(cpr); + checkCmdOnDriver(driver.run("insert into tab_not_acid values(1,1,'one'),(2,2,'two')")); + checkCmdOnDriver(driver.run("insert into tab1 partition(p) values(3,3,'one'),(4,4,'two')"));//txinid:1 + //writing both acid and non-acid resources in the same txn + //tab1 write is a dynamic partition insert + checkCmdOnDriver(driver.run("from tab_not_acid insert into tab1 partition(p)(a,b,p) select a,b,p insert into tab_not_acid(a,b) select a,b where p='two'"));//txnid:2 + Assert.assertEquals(TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 4, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS")); + //only expect transactional components to be in COMPLETED_TXN_COMPONENTS + Assert.assertEquals(TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 2, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=2")); + Assert.assertEquals(TxnDbUtil.queryToString("select * from COMPLETED_TXN_COMPONENTS"), + 2, TxnDbUtil.countQueryAgent("select count(*) from COMPLETED_TXN_COMPONENTS where ctc_txnid=2 and ctc_table='tab1'")); + } + //todo: Concurrent insert/update of same partition - should pass private List getLocksWithFilterOptions(HiveTxnManager txnMgr, String dbName, String tblName, Map partSpec) throws Exception { diff --git ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestCleaner.java ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestCleaner.java index 1578bfb..44dd99b 100644 --- ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestCleaner.java +++ ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestCleaner.java @@ -21,6 +21,7 @@ import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.metastore.api.CompactionRequest; import org.apache.hadoop.hive.metastore.api.CompactionType; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockLevel; import org.apache.hadoop.hive.metastore.api.LockRequest; @@ -222,6 +223,7 @@ public void blockedByLockTable() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "default"); comp.setTablename("bblt"); + comp.setOperationType(DataOperationType.SELECT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -260,6 +262,7 @@ public void blockedByLockPartition() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("bblp"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -302,6 +305,7 @@ public void notBlockedBySubsequentLock() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "default"); comp.setTablename("bblt"); + comp.setOperationType(DataOperationType.INSERT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -325,6 +329,7 @@ public void notBlockedBySubsequentLock() throws Exception { // clean request LockComponent comp2 = new LockComponent(LockType.SHARED_READ, LockLevel.TABLE, "default"); comp2.setTablename("bblt"); + comp.setOperationType(DataOperationType.SELECT); List components2 = new ArrayList(1); components2.add(comp2); LockRequest req2 = new LockRequest(components, "me", "localhost"); @@ -374,6 +379,7 @@ public void partitionNotBlockedBySubsequentLock() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_READ, LockLevel.PARTITION, "default"); comp.setTablename("bblt"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.INSERT); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -399,6 +405,7 @@ public void partitionNotBlockedBySubsequentLock() throws Exception { LockComponent comp2 = new LockComponent(LockType.SHARED_READ, LockLevel.PARTITION, "default"); comp2.setTablename("bblt"); comp2.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.SELECT); List components2 = new ArrayList(1); components2.add(comp2); LockRequest req2 = new LockRequest(components, "me", "localhost"); diff --git ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestInitiator.java ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestInitiator.java index a31e2d1..a11fe86 100644 --- ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestInitiator.java +++ ql/src/test/org/apache/hadoop/hive/ql/txn/compactor/TestInitiator.java @@ -22,6 +22,7 @@ import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; import org.apache.hadoop.hive.metastore.api.CompactionRequest; import org.apache.hadoop.hive.metastore.api.CompactionType; +import org.apache.hadoop.hive.metastore.api.DataOperationType; import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockLevel; @@ -123,6 +124,7 @@ public void majorCompactOnTableTooManyAborts() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("mcottma"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -153,6 +155,7 @@ public void majorCompactOnPartitionTooManyAborts() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("mcoptma"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -186,6 +189,7 @@ public void noCompactOnManyDifferentPartitionAborts() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("ncomdpa"); comp.setPartitionname("ds=day-" + i); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -210,6 +214,7 @@ public void cleanEmptyAbortedTxns() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("ceat"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -242,6 +247,7 @@ public void noCompactWhenNoCompactSet() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("ncwncs"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -267,6 +273,7 @@ public void noCompactWhenNoCompactSetLowerCase() throws Exception { for (int i = 0; i < 11; i++) { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); + comp.setOperationType(DataOperationType.DELETE); comp.setTablename("ncwncs"); List components = new ArrayList(1); components.add(comp); @@ -292,6 +299,7 @@ public void noCompactWhenCompactAlreadyScheduled() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("ncwcas"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -332,6 +340,7 @@ public void compactTableHighDeltaPct() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("cthdp"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -364,6 +373,7 @@ public void compactPartitionHighDeltaPct() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("cphdp"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -395,6 +405,7 @@ public void noCompactTableDeltaPctNotHighEnough() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("nctdpnhe"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -430,6 +441,7 @@ public void compactTableTooManyDeltas() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("cttmd"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -471,6 +483,7 @@ public void compactPartitionTooManyDeltas() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("cptmd"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -502,6 +515,7 @@ public void noCompactTableNotEnoughDeltas() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("nctned"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -537,6 +551,7 @@ public void chooseMajorOverMinorWhenBothValid() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("cmomwbv"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -577,6 +592,7 @@ public void enoughDeltasNoBase() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("ednb"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.DELETE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -610,6 +626,7 @@ public void twoTxnsOnSamePartitionGenerateOneCompactionRequest() throws Exceptio LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("ttospgocr"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -621,6 +638,7 @@ public void twoTxnsOnSamePartitionGenerateOneCompactionRequest() throws Exceptio comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("ttospgocr"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.UPDATE); components = new ArrayList(1); components.add(comp); req = new LockRequest(components, "me", "localhost"); @@ -653,6 +671,7 @@ public void noCompactTableDynamicPartitioning() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.TABLE, "default"); comp.setTablename("nctdp"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -680,6 +699,7 @@ public void dropTable() throws Exception { long txnid = openTxn(); LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("dt"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost"); @@ -711,6 +731,7 @@ public void dropPartition() throws Exception { LockComponent comp = new LockComponent(LockType.SHARED_WRITE, LockLevel.PARTITION, "default"); comp.setTablename("dp"); comp.setPartitionname("ds=today"); + comp.setOperationType(DataOperationType.UPDATE); List components = new ArrayList(1); components.add(comp); LockRequest req = new LockRequest(components, "me", "localhost");