diff --git common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java index 334b93e..edeab00 100644 --- common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java +++ common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java @@ -19,6 +19,7 @@ package org.apache.hadoop.hive.common; import java.util.Arrays; +import java.util.BitSet; /** * An implementation of {@link org.apache.hadoop.hive.common.ValidTxnList} for use by the compactor. @@ -44,7 +45,7 @@ public ValidCompactorTxnList() { * equivalently (lowest_open_txn - 1). */ public ValidCompactorTxnList(long[] abortedTxnList, long highWatermark) { - super(abortedTxnList, highWatermark); + super(abortedTxnList, new BitSet(), highWatermark); // ValidCompactorTxnList doesn't need abortedBits since everything in exceptions are aborted if(this.exceptions.length <= 0) { return; } @@ -75,4 +76,27 @@ public ValidCompactorTxnList(String value) { public RangeResponse isTxnRangeValid(long minTxnId, long maxTxnId) { return highWatermark >= maxTxnId ? RangeResponse.ALL : RangeResponse.NONE; } + + @Override + public boolean isTxnAborted(long txnid) { + return Arrays.binarySearch(exceptions, txnid) >= 0; + } + + @Override + public RangeResponse isTxnRangeAborted(long minTxnId, long maxTxnId) { + int count = 0; + for (long txnId = minTxnId; txnId <= maxTxnId; txnId++) { + if (Arrays.binarySearch(this.exceptions, txnId) >= 0) { + count += 1; + } + } + + if (count == 0) { + return RangeResponse.NONE; + } else if (count == (maxTxnId - minTxnId + 1)) { + return RangeResponse.ALL; + } else { + return RangeResponse.SOME; + } + } } diff --git common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java index 2f35917..18e32e1 100644 --- common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java +++ common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java @@ -21,6 +21,7 @@ import com.google.common.annotations.VisibleForTesting; import java.util.Arrays; +import java.util.BitSet; /** * An implementation of {@link org.apache.hadoop.hive.common.ValidTxnList} for use by readers. @@ -30,21 +31,22 @@ public class ValidReadTxnList implements ValidTxnList { protected long[] exceptions; + protected BitSet abortedBits; // BitSet for flagging aborted transactions. True if aborted, false if open //default value means there are no open txn in the snapshot private long minOpenTxn = Long.MAX_VALUE; protected long highWatermark; public ValidReadTxnList() { - this(new long[0], Long.MAX_VALUE, Long.MAX_VALUE); + this(new long[0], new BitSet(), Long.MAX_VALUE, Long.MAX_VALUE); } /** * Used if there are no open transactions in the snapshot */ - public ValidReadTxnList(long[] exceptions, long highWatermark) { - this(exceptions, highWatermark, Long.MAX_VALUE); + public ValidReadTxnList(long[] exceptions, BitSet abortedBits, long highWatermark) { + this(exceptions, abortedBits, highWatermark, Long.MAX_VALUE); } - public ValidReadTxnList(long[] exceptions, long highWatermark, long minOpenTxn) { + public ValidReadTxnList(long[] exceptions, BitSet abortedBits, long highWatermark, long minOpenTxn) { if (exceptions.length == 0) { this.exceptions = exceptions; } else { @@ -56,6 +58,7 @@ public ValidReadTxnList(long[] exceptions, long highWatermark, long minOpenTxn) throw new IllegalArgumentException("Invalid txnid: " + this.exceptions[0] + " found"); } } + this.abortedBits = abortedBits; this.highWatermark = highWatermark; } @@ -157,5 +160,37 @@ public long getHighWatermark() { public long getMinOpenTxn() { return minOpenTxn; } + + @Override + public boolean isTxnAborted(long txnid) { + int index = Arrays.binarySearch(exceptions, txnid); + return index >= 0 && abortedBits.get(index); + } + + @Override + public RangeResponse isTxnRangeAborted(long minTxnId, long maxTxnId) { + // check the easy cases first + if (highWatermark < minTxnId) { + return RangeResponse.NONE; + } + + long count = Math.max(0, maxTxnId - highWatermark); + for (long txn : exceptions) { + if (minTxnId <= txn && txn <= maxTxnId) { + int index = Arrays.binarySearch(exceptions, txn); + if (abortedBits.get(index)) { + count += 1; + } + } + } + + if (count == (maxTxnId - minTxnId + 1)) { + return RangeResponse.ALL; + } else if (count == 0) { + return RangeResponse.NONE; + } else { + return RangeResponse.SOME; + } + } } diff --git common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java index 5e1e4ee..0cc2298 100644 --- common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java +++ common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java @@ -89,4 +89,20 @@ * @return a list of invalid transaction ids */ public long[] getInvalidTransactions(); + + /** + * Indicates whether a given transaction is aborted. + * @param txnid id for the transaction + * @return true if aborted, false otherwise + */ + public boolean isTxnAborted(long txnid); + + /** + * Find out if a range of transaction ids are aborted. + * @param minTxnId minimum txnid to look for, inclusive + * @param maxTxnId maximum txnid to look for, inclusive + * @return Indicate whether none, some, or all of these transactions are aborted. + */ + public RangeResponse isTxnRangeAborted(long minTxnId, long maxTxnId); + } diff --git common/src/test/org/apache/hadoop/hive/common/TestValidReadTxnList.java common/src/test/org/apache/hadoop/hive/common/TestValidReadTxnList.java index 6661158..84725f7 100644 --- common/src/test/org/apache/hadoop/hive/common/TestValidReadTxnList.java +++ common/src/test/org/apache/hadoop/hive/common/TestValidReadTxnList.java @@ -26,6 +26,7 @@ import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; +import java.util.BitSet; /** * Tests for {@link ValidReadTxnList} @@ -34,7 +35,7 @@ @Test public void noExceptions() throws Exception { - ValidTxnList txnList = new ValidReadTxnList(new long[0], 1, Long.MAX_VALUE); + ValidTxnList txnList = new ValidReadTxnList(new long[0], new BitSet(), 1, Long.MAX_VALUE); String str = txnList.writeToString(); Assert.assertEquals("1:" + Long.MAX_VALUE + ":", str); ValidTxnList newList = new ValidReadTxnList(); @@ -45,7 +46,7 @@ public void noExceptions() throws Exception { @Test public void exceptions() throws Exception { - ValidTxnList txnList = new ValidReadTxnList(new long[]{2L,4L}, 5, 4L); + ValidTxnList txnList = new ValidReadTxnList(new long[]{2L,4L}, new BitSet(), 5, 4L); String str = txnList.writeToString(); Assert.assertEquals("5:4:2:4", str); ValidTxnList newList = new ValidReadTxnList(); @@ -62,7 +63,7 @@ public void exceptions() throws Exception { public void longEnoughToCompress() throws Exception { long[] exceptions = new long[1000]; for (int i = 0; i < 1000; i++) exceptions[i] = i + 100; - ValidTxnList txnList = new ValidReadTxnList(exceptions, 2000, 900); + ValidTxnList txnList = new ValidReadTxnList(exceptions, new BitSet(), 2000, 900); String str = txnList.writeToString(); ValidTxnList newList = new ValidReadTxnList(); newList.readFromString(str); @@ -76,7 +77,7 @@ public void longEnoughToCompress() throws Exception { public void readWriteConfig() throws Exception { long[] exceptions = new long[1000]; for (int i = 0; i < 1000; i++) exceptions[i] = i + 100; - ValidTxnList txnList = new ValidReadTxnList(exceptions, 2000, 900); + ValidTxnList txnList = new ValidReadTxnList(exceptions, new BitSet(), 2000, 900); String str = txnList.writeToString(); Configuration conf = new Configuration(); conf.set(ValidTxnList.VALID_TXNS_KEY, str); diff --git itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestCompactor.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestCompactor.java index 66ed8ca..439d2a3 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestCompactor.java +++ itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestCompactor.java @@ -1332,6 +1332,16 @@ public long getHighWatermark() { public boolean isValidBase(long txnid) { return true; } + + @Override + public boolean isTxnAborted(long txnid) { + return true; + } + + @Override + public RangeResponse isTxnRangeAborted(long minTxnId, long maxTxnId) { + return RangeResponse.ALL; + } }; OrcInputFormat aif = new OrcInputFormat(); diff --git metastore/if/hive_metastore.thrift metastore/if/hive_metastore.thrift index a1bdc30..6056663 100755 --- metastore/if/hive_metastore.thrift +++ metastore/if/hive_metastore.thrift @@ -636,8 +636,9 @@ struct GetOpenTxnsInfoResponse { struct GetOpenTxnsResponse { 1: required i64 txn_high_water_mark, - 2: required set open_txns, + 2: required list open_txns, // since 3.0 3: optional i64 min_open_txn, //since 1.3,2.2 + 4: required binary abortedBits, // since 3.0 } struct OpenTxnRequest { diff --git metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 42de24e..18bdbeb 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 _size818; - ::apache::thrift::protocol::TType _etype821; - xfer += iprot->readListBegin(_etype821, _size818); - this->success.resize(_size818); - uint32_t _i822; - for (_i822 = 0; _i822 < _size818; ++_i822) + uint32_t _size817; + ::apache::thrift::protocol::TType _etype820; + xfer += iprot->readListBegin(_etype820, _size817); + this->success.resize(_size817); + uint32_t _i821; + for (_i821 = 0; _i821 < _size817; ++_i821) { - xfer += iprot->readString(this->success[_i822]); + xfer += iprot->readString(this->success[_i821]); } 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 _iter823; - for (_iter823 = this->success.begin(); _iter823 != this->success.end(); ++_iter823) + std::vector ::const_iterator _iter822; + for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter822)); } 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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - (*(this->success)).resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + uint32_t _size823; + ::apache::thrift::protocol::TType _etype826; + xfer += iprot->readListBegin(_etype826, _size823); + (*(this->success)).resize(_size823); + uint32_t _i827; + for (_i827 = 0; _i827 < _size823; ++_i827) { - xfer += iprot->readString((*(this->success))[_i828]); + xfer += iprot->readString((*(this->success))[_i827]); } 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 _size829; - ::apache::thrift::protocol::TType _etype832; - xfer += iprot->readListBegin(_etype832, _size829); - this->success.resize(_size829); - uint32_t _i833; - for (_i833 = 0; _i833 < _size829; ++_i833) + uint32_t _size828; + ::apache::thrift::protocol::TType _etype831; + xfer += iprot->readListBegin(_etype831, _size828); + this->success.resize(_size828); + uint32_t _i832; + for (_i832 = 0; _i832 < _size828; ++_i832) { - xfer += iprot->readString(this->success[_i833]); + xfer += iprot->readString(this->success[_i832]); } 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 _iter834; - for (_iter834 = this->success.begin(); _iter834 != this->success.end(); ++_iter834) + std::vector ::const_iterator _iter833; + for (_iter833 = this->success.begin(); _iter833 != this->success.end(); ++_iter833) { - xfer += oprot->writeString((*_iter834)); + xfer += oprot->writeString((*_iter833)); } 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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - (*(this->success)).resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + uint32_t _size834; + ::apache::thrift::protocol::TType _etype837; + xfer += iprot->readListBegin(_etype837, _size834); + (*(this->success)).resize(_size834); + uint32_t _i838; + for (_i838 = 0; _i838 < _size834; ++_i838) { - xfer += iprot->readString((*(this->success))[_i839]); + xfer += iprot->readString((*(this->success))[_i838]); } 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 _size840; - ::apache::thrift::protocol::TType _ktype841; - ::apache::thrift::protocol::TType _vtype842; - xfer += iprot->readMapBegin(_ktype841, _vtype842, _size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size839; + ::apache::thrift::protocol::TType _ktype840; + ::apache::thrift::protocol::TType _vtype841; + xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839); + uint32_t _i843; + for (_i843 = 0; _i843 < _size839; ++_i843) { - std::string _key845; - xfer += iprot->readString(_key845); - Type& _val846 = this->success[_key845]; - xfer += _val846.read(iprot); + std::string _key844; + xfer += iprot->readString(_key844); + Type& _val845 = this->success[_key844]; + xfer += _val845.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 _iter847; - for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847) + std::map ::const_iterator _iter846; + for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) { - xfer += oprot->writeString(_iter847->first); - xfer += _iter847->second.write(oprot); + xfer += oprot->writeString(_iter846->first); + xfer += _iter846->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 _size848; - ::apache::thrift::protocol::TType _ktype849; - ::apache::thrift::protocol::TType _vtype850; - xfer += iprot->readMapBegin(_ktype849, _vtype850, _size848); - uint32_t _i852; - for (_i852 = 0; _i852 < _size848; ++_i852) + uint32_t _size847; + ::apache::thrift::protocol::TType _ktype848; + ::apache::thrift::protocol::TType _vtype849; + xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); + uint32_t _i851; + for (_i851 = 0; _i851 < _size847; ++_i851) { - std::string _key853; - xfer += iprot->readString(_key853); - Type& _val854 = (*(this->success))[_key853]; - xfer += _val854.read(iprot); + std::string _key852; + xfer += iprot->readString(_key852); + Type& _val853 = (*(this->success))[_key852]; + xfer += _val853.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 _size855; - ::apache::thrift::protocol::TType _etype858; - xfer += iprot->readListBegin(_etype858, _size855); - this->success.resize(_size855); - uint32_t _i859; - for (_i859 = 0; _i859 < _size855; ++_i859) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->success.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += this->success[_i859].read(iprot); + xfer += this->success[_i858].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 _iter860; - for (_iter860 = this->success.begin(); _iter860 != this->success.end(); ++_iter860) + std::vector ::const_iterator _iter859; + for (_iter859 = this->success.begin(); _iter859 != this->success.end(); ++_iter859) { - xfer += (*_iter860).write(oprot); + xfer += (*_iter859).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 _size861; - ::apache::thrift::protocol::TType _etype864; - xfer += iprot->readListBegin(_etype864, _size861); - (*(this->success)).resize(_size861); - uint32_t _i865; - for (_i865 = 0; _i865 < _size861; ++_i865) + uint32_t _size860; + ::apache::thrift::protocol::TType _etype863; + xfer += iprot->readListBegin(_etype863, _size860); + (*(this->success)).resize(_size860); + uint32_t _i864; + for (_i864 = 0; _i864 < _size860; ++_i864) { - xfer += (*(this->success))[_i865].read(iprot); + xfer += (*(this->success))[_i864].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 _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 _size865; + ::apache::thrift::protocol::TType _etype868; + xfer += iprot->readListBegin(_etype868, _size865); + this->success.resize(_size865); + uint32_t _i869; + for (_i869 = 0; _i869 < _size865; ++_i869) { - xfer += this->success[_i870].read(iprot); + xfer += this->success[_i869].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 _iter871; - for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) + std::vector ::const_iterator _iter870; + for (_iter870 = this->success.begin(); _iter870 != this->success.end(); ++_iter870) { - xfer += (*_iter871).write(oprot); + xfer += (*_iter870).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 _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 _size871; + ::apache::thrift::protocol::TType _etype874; + xfer += iprot->readListBegin(_etype874, _size871); + (*(this->success)).resize(_size871); + uint32_t _i875; + for (_i875 = 0; _i875 < _size871; ++_i875) { - xfer += (*(this->success))[_i876].read(iprot); + xfer += (*(this->success))[_i875].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 _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - this->success.resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + uint32_t _size876; + ::apache::thrift::protocol::TType _etype879; + xfer += iprot->readListBegin(_etype879, _size876); + this->success.resize(_size876); + uint32_t _i880; + for (_i880 = 0; _i880 < _size876; ++_i880) { - xfer += this->success[_i881].read(iprot); + xfer += this->success[_i880].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 _iter882; - for (_iter882 = this->success.begin(); _iter882 != this->success.end(); ++_iter882) + std::vector ::const_iterator _iter881; + for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) { - xfer += (*_iter882).write(oprot); + xfer += (*_iter881).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 _size883; - ::apache::thrift::protocol::TType _etype886; - xfer += iprot->readListBegin(_etype886, _size883); - (*(this->success)).resize(_size883); - uint32_t _i887; - for (_i887 = 0; _i887 < _size883; ++_i887) + uint32_t _size882; + ::apache::thrift::protocol::TType _etype885; + xfer += iprot->readListBegin(_etype885, _size882); + (*(this->success)).resize(_size882); + uint32_t _i886; + for (_i886 = 0; _i886 < _size882; ++_i886) { - xfer += (*(this->success))[_i887].read(iprot); + xfer += (*(this->success))[_i886].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 _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->success.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->success.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += this->success[_i892].read(iprot); + xfer += this->success[_i891].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 _iter893; - for (_iter893 = this->success.begin(); _iter893 != this->success.end(); ++_iter893) + std::vector ::const_iterator _iter892; + for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) { - xfer += (*_iter893).write(oprot); + xfer += (*_iter892).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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - (*(this->success)).resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size893; + ::apache::thrift::protocol::TType _etype896; + xfer += iprot->readListBegin(_etype896, _size893); + (*(this->success)).resize(_size893); + uint32_t _i897; + for (_i897 = 0; _i897 < _size893; ++_i897) { - xfer += (*(this->success))[_i898].read(iprot); + xfer += (*(this->success))[_i897].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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->primaryKeys.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->primaryKeys.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += this->primaryKeys[_i903].read(iprot); + xfer += this->primaryKeys[_i902].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 _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->foreignKeys.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size903; + ::apache::thrift::protocol::TType _etype906; + xfer += iprot->readListBegin(_etype906, _size903); + this->foreignKeys.resize(_size903); + uint32_t _i907; + for (_i907 = 0; _i907 < _size903; ++_i907) { - xfer += this->foreignKeys[_i908].read(iprot); + xfer += this->foreignKeys[_i907].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 _iter909; - for (_iter909 = this->primaryKeys.begin(); _iter909 != this->primaryKeys.end(); ++_iter909) + std::vector ::const_iterator _iter908; + for (_iter908 = this->primaryKeys.begin(); _iter908 != this->primaryKeys.end(); ++_iter908) { - xfer += (*_iter909).write(oprot); + xfer += (*_iter908).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 _iter910; - for (_iter910 = this->foreignKeys.begin(); _iter910 != this->foreignKeys.end(); ++_iter910) + std::vector ::const_iterator _iter909; + for (_iter909 = this->foreignKeys.begin(); _iter909 != this->foreignKeys.end(); ++_iter909) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter909).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 _iter911; - for (_iter911 = (*(this->primaryKeys)).begin(); _iter911 != (*(this->primaryKeys)).end(); ++_iter911) + std::vector ::const_iterator _iter910; + for (_iter910 = (*(this->primaryKeys)).begin(); _iter910 != (*(this->primaryKeys)).end(); ++_iter910) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter910).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 _iter912; - for (_iter912 = (*(this->foreignKeys)).begin(); _iter912 != (*(this->foreignKeys)).end(); ++_iter912) + std::vector ::const_iterator _iter911; + for (_iter911 = (*(this->foreignKeys)).begin(); _iter911 != (*(this->foreignKeys)).end(); ++_iter911) { - xfer += (*_iter912).write(oprot); + xfer += (*_iter911).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 _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 _size912; + ::apache::thrift::protocol::TType _etype915; + xfer += iprot->readListBegin(_etype915, _size912); + this->success.resize(_size912); + uint32_t _i916; + for (_i916 = 0; _i916 < _size912; ++_i916) { - xfer += iprot->readString(this->success[_i917]); + xfer += iprot->readString(this->success[_i916]); } 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 _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector ::const_iterator _iter917; + for (_iter917 = this->success.begin(); _iter917 != this->success.end(); ++_iter917) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter917)); } 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 _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 _size918; + ::apache::thrift::protocol::TType _etype921; + xfer += iprot->readListBegin(_etype921, _size918); + (*(this->success)).resize(_size918); + uint32_t _i922; + for (_i922 = 0; _i922 < _size918; ++_i922) { - xfer += iprot->readString((*(this->success))[_i923]); + xfer += iprot->readString((*(this->success))[_i922]); } xfer += iprot->readListEnd(); } @@ -6326,14 +6326,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p 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 _size923; + ::apache::thrift::protocol::TType _etype926; + xfer += iprot->readListBegin(_etype926, _size923); + this->success.resize(_size923); + uint32_t _i927; + for (_i927 = 0; _i927 < _size923; ++_i927) { - xfer += iprot->readString(this->success[_i928]); + xfer += iprot->readString(this->success[_i927]); } xfer += iprot->readListEnd(); } @@ -6372,10 +6372,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_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 _iter929; - for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) + std::vector ::const_iterator _iter928; + for (_iter928 = this->success.begin(); _iter928 != this->success.end(); ++_iter928) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter928)); } xfer += oprot->writeListEnd(); } @@ -6420,14 +6420,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: 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 _size929; + ::apache::thrift::protocol::TType _etype932; + xfer += iprot->readListBegin(_etype932, _size929); + (*(this->success)).resize(_size929); + uint32_t _i933; + for (_i933 = 0; _i933 < _size929; ++_i933) { - xfer += iprot->readString((*(this->success))[_i934]); + xfer += iprot->readString((*(this->success))[_i933]); } xfer += iprot->readListEnd(); } @@ -6502,14 +6502,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 _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->tbl_types.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size934; + ::apache::thrift::protocol::TType _etype937; + xfer += iprot->readListBegin(_etype937, _size934); + this->tbl_types.resize(_size934); + uint32_t _i938; + for (_i938 = 0; _i938 < _size934; ++_i938) { - xfer += iprot->readString(this->tbl_types[_i939]); + xfer += iprot->readString(this->tbl_types[_i938]); } xfer += iprot->readListEnd(); } @@ -6546,10 +6546,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 _iter940; - for (_iter940 = this->tbl_types.begin(); _iter940 != this->tbl_types.end(); ++_iter940) + std::vector ::const_iterator _iter939; + for (_iter939 = this->tbl_types.begin(); _iter939 != this->tbl_types.end(); ++_iter939) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter939)); } xfer += oprot->writeListEnd(); } @@ -6581,10 +6581,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 _iter941; - for (_iter941 = (*(this->tbl_types)).begin(); _iter941 != (*(this->tbl_types)).end(); ++_iter941) + std::vector ::const_iterator _iter940; + for (_iter940 = (*(this->tbl_types)).begin(); _iter940 != (*(this->tbl_types)).end(); ++_iter940) { - xfer += oprot->writeString((*_iter941)); + xfer += oprot->writeString((*_iter940)); } xfer += oprot->writeListEnd(); } @@ -6625,14 +6625,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->success.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size941; + ::apache::thrift::protocol::TType _etype944; + xfer += iprot->readListBegin(_etype944, _size941); + this->success.resize(_size941); + uint32_t _i945; + for (_i945 = 0; _i945 < _size941; ++_i945) { - xfer += this->success[_i946].read(iprot); + xfer += this->success[_i945].read(iprot); } xfer += iprot->readListEnd(); } @@ -6671,10 +6671,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 _iter947; - for (_iter947 = this->success.begin(); _iter947 != this->success.end(); ++_iter947) + std::vector ::const_iterator _iter946; + for (_iter946 = this->success.begin(); _iter946 != this->success.end(); ++_iter946) { - xfer += (*_iter947).write(oprot); + xfer += (*_iter946).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6719,14 +6719,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - (*(this->success)).resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size947; + ::apache::thrift::protocol::TType _etype950; + xfer += iprot->readListBegin(_etype950, _size947); + (*(this->success)).resize(_size947); + uint32_t _i951; + for (_i951 = 0; _i951 < _size947; ++_i951) { - xfer += (*(this->success))[_i952].read(iprot); + xfer += (*(this->success))[_i951].read(iprot); } xfer += iprot->readListEnd(); } @@ -6864,14 +6864,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - this->success.resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size952; + ::apache::thrift::protocol::TType _etype955; + xfer += iprot->readListBegin(_etype955, _size952); + this->success.resize(_size952); + uint32_t _i956; + for (_i956 = 0; _i956 < _size952; ++_i956) { - xfer += iprot->readString(this->success[_i957]); + xfer += iprot->readString(this->success[_i956]); } xfer += iprot->readListEnd(); } @@ -6910,10 +6910,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 _iter958; - for (_iter958 = this->success.begin(); _iter958 != this->success.end(); ++_iter958) + std::vector ::const_iterator _iter957; + for (_iter957 = this->success.begin(); _iter957 != this->success.end(); ++_iter957) { - xfer += oprot->writeString((*_iter958)); + xfer += oprot->writeString((*_iter957)); } xfer += oprot->writeListEnd(); } @@ -6958,14 +6958,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size959; - ::apache::thrift::protocol::TType _etype962; - xfer += iprot->readListBegin(_etype962, _size959); - (*(this->success)).resize(_size959); - uint32_t _i963; - for (_i963 = 0; _i963 < _size959; ++_i963) + uint32_t _size958; + ::apache::thrift::protocol::TType _etype961; + xfer += iprot->readListBegin(_etype961, _size958); + (*(this->success)).resize(_size958); + uint32_t _i962; + for (_i962 = 0; _i962 < _size958; ++_i962) { - xfer += iprot->readString((*(this->success))[_i963]); + xfer += iprot->readString((*(this->success))[_i962]); } xfer += iprot->readListEnd(); } @@ -7275,14 +7275,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 _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->tbl_names.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size963; + ::apache::thrift::protocol::TType _etype966; + xfer += iprot->readListBegin(_etype966, _size963); + this->tbl_names.resize(_size963); + uint32_t _i967; + for (_i967 = 0; _i967 < _size963; ++_i967) { - xfer += iprot->readString(this->tbl_names[_i968]); + xfer += iprot->readString(this->tbl_names[_i967]); } xfer += iprot->readListEnd(); } @@ -7315,10 +7315,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 _iter969; - for (_iter969 = this->tbl_names.begin(); _iter969 != this->tbl_names.end(); ++_iter969) + std::vector ::const_iterator _iter968; + for (_iter968 = this->tbl_names.begin(); _iter968 != this->tbl_names.end(); ++_iter968) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter968)); } xfer += oprot->writeListEnd(); } @@ -7346,10 +7346,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 _iter970; - for (_iter970 = (*(this->tbl_names)).begin(); _iter970 != (*(this->tbl_names)).end(); ++_iter970) + std::vector ::const_iterator _iter969; + for (_iter969 = (*(this->tbl_names)).begin(); _iter969 != (*(this->tbl_names)).end(); ++_iter969) { - xfer += oprot->writeString((*_iter970)); + xfer += oprot->writeString((*_iter969)); } xfer += oprot->writeListEnd(); } @@ -7390,14 +7390,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 _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->success.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size970; + ::apache::thrift::protocol::TType _etype973; + xfer += iprot->readListBegin(_etype973, _size970); + this->success.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += this->success[_i975].read(iprot); + xfer += this->success[_i974].read(iprot); } xfer += iprot->readListEnd(); } @@ -7428,10 +7428,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 _iter976; - for (_iter976 = this->success.begin(); _iter976 != this->success.end(); ++_iter976) + std::vector
::const_iterator _iter975; + for (_iter975 = this->success.begin(); _iter975 != this->success.end(); ++_iter975) { - xfer += (*_iter976).write(oprot); + xfer += (*_iter975).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7472,14 +7472,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 _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - (*(this->success)).resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size976; + ::apache::thrift::protocol::TType _etype979; + xfer += iprot->readListBegin(_etype979, _size976); + (*(this->success)).resize(_size976); + uint32_t _i980; + for (_i980 = 0; _i980 < _size976; ++_i980) { - xfer += (*(this->success))[_i981].read(iprot); + xfer += (*(this->success))[_i980].read(iprot); } xfer += iprot->readListEnd(); } @@ -8115,14 +8115,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 _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - this->success.resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size981; + ::apache::thrift::protocol::TType _etype984; + xfer += iprot->readListBegin(_etype984, _size981); + this->success.resize(_size981); + uint32_t _i985; + for (_i985 = 0; _i985 < _size981; ++_i985) { - xfer += iprot->readString(this->success[_i986]); + xfer += iprot->readString(this->success[_i985]); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,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 _iter987; - for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + std::vector ::const_iterator _iter986; + for (_iter986 = this->success.begin(); _iter986 != this->success.end(); ++_iter986) { - xfer += oprot->writeString((*_iter987)); + xfer += oprot->writeString((*_iter986)); } xfer += oprot->writeListEnd(); } @@ -8233,14 +8233,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 _size988; - ::apache::thrift::protocol::TType _etype991; - xfer += iprot->readListBegin(_etype991, _size988); - (*(this->success)).resize(_size988); - uint32_t _i992; - for (_i992 = 0; _i992 < _size988; ++_i992) + uint32_t _size987; + ::apache::thrift::protocol::TType _etype990; + xfer += iprot->readListBegin(_etype990, _size987); + (*(this->success)).resize(_size987); + uint32_t _i991; + for (_i991 = 0; _i991 < _size987; ++_i991) { - xfer += iprot->readString((*(this->success))[_i992]); + xfer += iprot->readString((*(this->success))[_i991]); } xfer += iprot->readListEnd(); } @@ -9574,14 +9574,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->new_parts.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size992; + ::apache::thrift::protocol::TType _etype995; + xfer += iprot->readListBegin(_etype995, _size992); + this->new_parts.resize(_size992); + uint32_t _i996; + for (_i996 = 0; _i996 < _size992; ++_i996) { - xfer += this->new_parts[_i997].read(iprot); + xfer += this->new_parts[_i996].read(iprot); } xfer += iprot->readListEnd(); } @@ -9610,10 +9610,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 _iter998; - for (_iter998 = this->new_parts.begin(); _iter998 != this->new_parts.end(); ++_iter998) + std::vector ::const_iterator _iter997; + for (_iter997 = this->new_parts.begin(); _iter997 != this->new_parts.end(); ++_iter997) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter997).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9637,10 +9637,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 _iter999; - for (_iter999 = (*(this->new_parts)).begin(); _iter999 != (*(this->new_parts)).end(); ++_iter999) + std::vector ::const_iterator _iter998; + for (_iter998 = (*(this->new_parts)).begin(); _iter998 != (*(this->new_parts)).end(); ++_iter998) { - xfer += (*_iter999).write(oprot); + xfer += (*_iter998).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9849,14 +9849,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 _size1000; - ::apache::thrift::protocol::TType _etype1003; - xfer += iprot->readListBegin(_etype1003, _size1000); - this->new_parts.resize(_size1000); - uint32_t _i1004; - for (_i1004 = 0; _i1004 < _size1000; ++_i1004) + uint32_t _size999; + ::apache::thrift::protocol::TType _etype1002; + xfer += iprot->readListBegin(_etype1002, _size999); + this->new_parts.resize(_size999); + uint32_t _i1003; + for (_i1003 = 0; _i1003 < _size999; ++_i1003) { - xfer += this->new_parts[_i1004].read(iprot); + xfer += this->new_parts[_i1003].read(iprot); } xfer += iprot->readListEnd(); } @@ -9885,10 +9885,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 _iter1005; - for (_iter1005 = this->new_parts.begin(); _iter1005 != this->new_parts.end(); ++_iter1005) + std::vector ::const_iterator _iter1004; + for (_iter1004 = this->new_parts.begin(); _iter1004 != this->new_parts.end(); ++_iter1004) { - xfer += (*_iter1005).write(oprot); + xfer += (*_iter1004).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9912,10 +9912,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 _iter1006; - for (_iter1006 = (*(this->new_parts)).begin(); _iter1006 != (*(this->new_parts)).end(); ++_iter1006) + std::vector ::const_iterator _iter1005; + for (_iter1005 = (*(this->new_parts)).begin(); _iter1005 != (*(this->new_parts)).end(); ++_iter1005) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1005).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10140,14 +10140,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->part_vals.resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1006; + ::apache::thrift::protocol::TType _etype1009; + xfer += iprot->readListBegin(_etype1009, _size1006); + this->part_vals.resize(_size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - xfer += iprot->readString(this->part_vals[_i1011]); + xfer += iprot->readString(this->part_vals[_i1010]); } xfer += iprot->readListEnd(); } @@ -10184,10 +10184,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 _iter1012; - for (_iter1012 = this->part_vals.begin(); _iter1012 != this->part_vals.end(); ++_iter1012) + std::vector ::const_iterator _iter1011; + for (_iter1011 = this->part_vals.begin(); _iter1011 != this->part_vals.end(); ++_iter1011) { - xfer += oprot->writeString((*_iter1012)); + xfer += oprot->writeString((*_iter1011)); } xfer += oprot->writeListEnd(); } @@ -10219,10 +10219,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 _iter1013; - for (_iter1013 = (*(this->part_vals)).begin(); _iter1013 != (*(this->part_vals)).end(); ++_iter1013) + std::vector ::const_iterator _iter1012; + for (_iter1012 = (*(this->part_vals)).begin(); _iter1012 != (*(this->part_vals)).end(); ++_iter1012) { - xfer += oprot->writeString((*_iter1013)); + xfer += oprot->writeString((*_iter1012)); } xfer += oprot->writeListEnd(); } @@ -10694,14 +10694,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1014; - ::apache::thrift::protocol::TType _etype1017; - xfer += iprot->readListBegin(_etype1017, _size1014); - this->part_vals.resize(_size1014); - uint32_t _i1018; - for (_i1018 = 0; _i1018 < _size1014; ++_i1018) + 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) { - xfer += iprot->readString(this->part_vals[_i1018]); + xfer += iprot->readString(this->part_vals[_i1017]); } xfer += iprot->readListEnd(); } @@ -10746,10 +10746,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 _iter1019; - for (_iter1019 = this->part_vals.begin(); _iter1019 != this->part_vals.end(); ++_iter1019) + std::vector ::const_iterator _iter1018; + for (_iter1018 = this->part_vals.begin(); _iter1018 != this->part_vals.end(); ++_iter1018) { - xfer += oprot->writeString((*_iter1019)); + xfer += oprot->writeString((*_iter1018)); } xfer += oprot->writeListEnd(); } @@ -10785,10 +10785,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 _iter1020; - for (_iter1020 = (*(this->part_vals)).begin(); _iter1020 != (*(this->part_vals)).end(); ++_iter1020) + std::vector ::const_iterator _iter1019; + for (_iter1019 = (*(this->part_vals)).begin(); _iter1019 != (*(this->part_vals)).end(); ++_iter1019) { - xfer += oprot->writeString((*_iter1020)); + xfer += oprot->writeString((*_iter1019)); } xfer += oprot->writeListEnd(); } @@ -11591,14 +11591,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->part_vals.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1020; + ::apache::thrift::protocol::TType _etype1023; + xfer += iprot->readListBegin(_etype1023, _size1020); + this->part_vals.resize(_size1020); + uint32_t _i1024; + for (_i1024 = 0; _i1024 < _size1020; ++_i1024) { - xfer += iprot->readString(this->part_vals[_i1025]); + xfer += iprot->readString(this->part_vals[_i1024]); } xfer += iprot->readListEnd(); } @@ -11643,10 +11643,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 _iter1026; - for (_iter1026 = this->part_vals.begin(); _iter1026 != this->part_vals.end(); ++_iter1026) + std::vector ::const_iterator _iter1025; + for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1025)); } xfer += oprot->writeListEnd(); } @@ -11682,10 +11682,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 _iter1027; - for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) + std::vector ::const_iterator _iter1026; + for (_iter1026 = (*(this->part_vals)).begin(); _iter1026 != (*(this->part_vals)).end(); ++_iter1026) { - xfer += oprot->writeString((*_iter1027)); + xfer += oprot->writeString((*_iter1026)); } xfer += oprot->writeListEnd(); } @@ -11894,14 +11894,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1028; - ::apache::thrift::protocol::TType _etype1031; - xfer += iprot->readListBegin(_etype1031, _size1028); - this->part_vals.resize(_size1028); - uint32_t _i1032; - for (_i1032 = 0; _i1032 < _size1028; ++_i1032) + uint32_t _size1027; + ::apache::thrift::protocol::TType _etype1030; + xfer += iprot->readListBegin(_etype1030, _size1027); + this->part_vals.resize(_size1027); + uint32_t _i1031; + for (_i1031 = 0; _i1031 < _size1027; ++_i1031) { - xfer += iprot->readString(this->part_vals[_i1032]); + xfer += iprot->readString(this->part_vals[_i1031]); } xfer += iprot->readListEnd(); } @@ -11954,10 +11954,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 _iter1033; - for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) + std::vector ::const_iterator _iter1032; + for (_iter1032 = this->part_vals.begin(); _iter1032 != this->part_vals.end(); ++_iter1032) { - xfer += oprot->writeString((*_iter1033)); + xfer += oprot->writeString((*_iter1032)); } xfer += oprot->writeListEnd(); } @@ -11997,10 +11997,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 _iter1034; - for (_iter1034 = (*(this->part_vals)).begin(); _iter1034 != (*(this->part_vals)).end(); ++_iter1034) + std::vector ::const_iterator _iter1033; + for (_iter1033 = (*(this->part_vals)).begin(); _iter1033 != (*(this->part_vals)).end(); ++_iter1033) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1033)); } xfer += oprot->writeListEnd(); } @@ -13006,14 +13006,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - this->part_vals.resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + uint32_t _size1034; + ::apache::thrift::protocol::TType _etype1037; + xfer += iprot->readListBegin(_etype1037, _size1034); + this->part_vals.resize(_size1034); + uint32_t _i1038; + for (_i1038 = 0; _i1038 < _size1034; ++_i1038) { - xfer += iprot->readString(this->part_vals[_i1039]); + xfer += iprot->readString(this->part_vals[_i1038]); } xfer += iprot->readListEnd(); } @@ -13050,10 +13050,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 _iter1040; - for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) + std::vector ::const_iterator _iter1039; + for (_iter1039 = this->part_vals.begin(); _iter1039 != this->part_vals.end(); ++_iter1039) { - xfer += oprot->writeString((*_iter1040)); + xfer += oprot->writeString((*_iter1039)); } xfer += oprot->writeListEnd(); } @@ -13085,10 +13085,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 _iter1041; - for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) + std::vector ::const_iterator _iter1040; + for (_iter1040 = (*(this->part_vals)).begin(); _iter1040 != (*(this->part_vals)).end(); ++_iter1040) { - xfer += oprot->writeString((*_iter1041)); + xfer += oprot->writeString((*_iter1040)); } xfer += oprot->writeListEnd(); } @@ -13277,17 +13277,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _ktype1043; - ::apache::thrift::protocol::TType _vtype1044; - xfer += iprot->readMapBegin(_ktype1043, _vtype1044, _size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1041; + ::apache::thrift::protocol::TType _ktype1042; + ::apache::thrift::protocol::TType _vtype1043; + xfer += iprot->readMapBegin(_ktype1042, _vtype1043, _size1041); + uint32_t _i1045; + for (_i1045 = 0; _i1045 < _size1041; ++_i1045) { - std::string _key1047; - xfer += iprot->readString(_key1047); - std::string& _val1048 = this->partitionSpecs[_key1047]; - xfer += iprot->readString(_val1048); + std::string _key1046; + xfer += iprot->readString(_key1046); + std::string& _val1047 = this->partitionSpecs[_key1046]; + xfer += iprot->readString(_val1047); } xfer += iprot->readMapEnd(); } @@ -13348,11 +13348,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 _iter1049; - for (_iter1049 = this->partitionSpecs.begin(); _iter1049 != this->partitionSpecs.end(); ++_iter1049) + std::map ::const_iterator _iter1048; + for (_iter1048 = this->partitionSpecs.begin(); _iter1048 != this->partitionSpecs.end(); ++_iter1048) { - xfer += oprot->writeString(_iter1049->first); - xfer += oprot->writeString(_iter1049->second); + xfer += oprot->writeString(_iter1048->first); + xfer += oprot->writeString(_iter1048->second); } xfer += oprot->writeMapEnd(); } @@ -13392,11 +13392,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 _iter1050; - for (_iter1050 = (*(this->partitionSpecs)).begin(); _iter1050 != (*(this->partitionSpecs)).end(); ++_iter1050) + std::map ::const_iterator _iter1049; + for (_iter1049 = (*(this->partitionSpecs)).begin(); _iter1049 != (*(this->partitionSpecs)).end(); ++_iter1049) { - xfer += oprot->writeString(_iter1050->first); - xfer += oprot->writeString(_iter1050->second); + xfer += oprot->writeString(_iter1049->first); + xfer += oprot->writeString(_iter1049->second); } xfer += oprot->writeMapEnd(); } @@ -13641,17 +13641,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _ktype1052; - ::apache::thrift::protocol::TType _vtype1053; - xfer += iprot->readMapBegin(_ktype1052, _vtype1053, _size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1050; + ::apache::thrift::protocol::TType _ktype1051; + ::apache::thrift::protocol::TType _vtype1052; + xfer += iprot->readMapBegin(_ktype1051, _vtype1052, _size1050); + uint32_t _i1054; + for (_i1054 = 0; _i1054 < _size1050; ++_i1054) { - std::string _key1056; - xfer += iprot->readString(_key1056); - std::string& _val1057 = this->partitionSpecs[_key1056]; - xfer += iprot->readString(_val1057); + std::string _key1055; + xfer += iprot->readString(_key1055); + std::string& _val1056 = this->partitionSpecs[_key1055]; + xfer += iprot->readString(_val1056); } xfer += iprot->readMapEnd(); } @@ -13712,11 +13712,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 _iter1058; - for (_iter1058 = this->partitionSpecs.begin(); _iter1058 != this->partitionSpecs.end(); ++_iter1058) + std::map ::const_iterator _iter1057; + for (_iter1057 = this->partitionSpecs.begin(); _iter1057 != this->partitionSpecs.end(); ++_iter1057) { - xfer += oprot->writeString(_iter1058->first); - xfer += oprot->writeString(_iter1058->second); + xfer += oprot->writeString(_iter1057->first); + xfer += oprot->writeString(_iter1057->second); } xfer += oprot->writeMapEnd(); } @@ -13756,11 +13756,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 _iter1059; - for (_iter1059 = (*(this->partitionSpecs)).begin(); _iter1059 != (*(this->partitionSpecs)).end(); ++_iter1059) + std::map ::const_iterator _iter1058; + for (_iter1058 = (*(this->partitionSpecs)).begin(); _iter1058 != (*(this->partitionSpecs)).end(); ++_iter1058) { - xfer += oprot->writeString(_iter1059->first); - xfer += oprot->writeString(_iter1059->second); + xfer += oprot->writeString(_iter1058->first); + xfer += oprot->writeString(_iter1058->second); } xfer += oprot->writeMapEnd(); } @@ -13817,14 +13817,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->success.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1059; + ::apache::thrift::protocol::TType _etype1062; + xfer += iprot->readListBegin(_etype1062, _size1059); + this->success.resize(_size1059); + uint32_t _i1063; + for (_i1063 = 0; _i1063 < _size1059; ++_i1063) { - xfer += this->success[_i1064].read(iprot); + xfer += this->success[_i1063].read(iprot); } xfer += iprot->readListEnd(); } @@ -13887,10 +13887,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 _iter1065; - for (_iter1065 = this->success.begin(); _iter1065 != this->success.end(); ++_iter1065) + std::vector ::const_iterator _iter1064; + for (_iter1064 = this->success.begin(); _iter1064 != this->success.end(); ++_iter1064) { - xfer += (*_iter1065).write(oprot); + xfer += (*_iter1064).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13947,14 +13947,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - (*(this->success)).resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + (*(this->success)).resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) { - xfer += (*(this->success))[_i1070].read(iprot); + xfer += (*(this->success))[_i1069].read(iprot); } xfer += iprot->readListEnd(); } @@ -14053,14 +14053,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 _size1071; - ::apache::thrift::protocol::TType _etype1074; - xfer += iprot->readListBegin(_etype1074, _size1071); - this->part_vals.resize(_size1071); - uint32_t _i1075; - for (_i1075 = 0; _i1075 < _size1071; ++_i1075) + uint32_t _size1070; + ::apache::thrift::protocol::TType _etype1073; + xfer += iprot->readListBegin(_etype1073, _size1070); + this->part_vals.resize(_size1070); + uint32_t _i1074; + for (_i1074 = 0; _i1074 < _size1070; ++_i1074) { - xfer += iprot->readString(this->part_vals[_i1075]); + xfer += iprot->readString(this->part_vals[_i1074]); } xfer += iprot->readListEnd(); } @@ -14081,14 +14081,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 _size1076; - ::apache::thrift::protocol::TType _etype1079; - xfer += iprot->readListBegin(_etype1079, _size1076); - this->group_names.resize(_size1076); - uint32_t _i1080; - for (_i1080 = 0; _i1080 < _size1076; ++_i1080) + uint32_t _size1075; + ::apache::thrift::protocol::TType _etype1078; + xfer += iprot->readListBegin(_etype1078, _size1075); + this->group_names.resize(_size1075); + uint32_t _i1079; + for (_i1079 = 0; _i1079 < _size1075; ++_i1079) { - xfer += iprot->readString(this->group_names[_i1080]); + xfer += iprot->readString(this->group_names[_i1079]); } xfer += iprot->readListEnd(); } @@ -14125,10 +14125,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 _iter1081; - for (_iter1081 = this->part_vals.begin(); _iter1081 != this->part_vals.end(); ++_iter1081) + std::vector ::const_iterator _iter1080; + for (_iter1080 = this->part_vals.begin(); _iter1080 != this->part_vals.end(); ++_iter1080) { - xfer += oprot->writeString((*_iter1081)); + xfer += oprot->writeString((*_iter1080)); } xfer += oprot->writeListEnd(); } @@ -14141,10 +14141,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 _iter1082; - for (_iter1082 = this->group_names.begin(); _iter1082 != this->group_names.end(); ++_iter1082) + std::vector ::const_iterator _iter1081; + for (_iter1081 = this->group_names.begin(); _iter1081 != this->group_names.end(); ++_iter1081) { - xfer += oprot->writeString((*_iter1082)); + xfer += oprot->writeString((*_iter1081)); } xfer += oprot->writeListEnd(); } @@ -14176,10 +14176,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 _iter1083; - for (_iter1083 = (*(this->part_vals)).begin(); _iter1083 != (*(this->part_vals)).end(); ++_iter1083) + std::vector ::const_iterator _iter1082; + for (_iter1082 = (*(this->part_vals)).begin(); _iter1082 != (*(this->part_vals)).end(); ++_iter1082) { - xfer += oprot->writeString((*_iter1083)); + xfer += oprot->writeString((*_iter1082)); } xfer += oprot->writeListEnd(); } @@ -14192,10 +14192,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 _iter1084; - for (_iter1084 = (*(this->group_names)).begin(); _iter1084 != (*(this->group_names)).end(); ++_iter1084) + std::vector ::const_iterator _iter1083; + for (_iter1083 = (*(this->group_names)).begin(); _iter1083 != (*(this->group_names)).end(); ++_iter1083) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1083)); } xfer += oprot->writeListEnd(); } @@ -14754,14 +14754,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto 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 _size1084; + ::apache::thrift::protocol::TType _etype1087; + xfer += iprot->readListBegin(_etype1087, _size1084); + this->success.resize(_size1084); + uint32_t _i1088; + for (_i1088 = 0; _i1088 < _size1084; ++_i1088) { - xfer += this->success[_i1089].read(iprot); + xfer += this->success[_i1088].read(iprot); } xfer += iprot->readListEnd(); } @@ -14808,10 +14808,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 _iter1090; - for (_iter1090 = this->success.begin(); _iter1090 != this->success.end(); ++_iter1090) + std::vector ::const_iterator _iter1089; + for (_iter1089 = this->success.begin(); _iter1089 != this->success.end(); ++_iter1089) { - xfer += (*_iter1090).write(oprot); + xfer += (*_iter1089).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14860,14 +14860,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot 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 _size1090; + ::apache::thrift::protocol::TType _etype1093; + xfer += iprot->readListBegin(_etype1093, _size1090); + (*(this->success)).resize(_size1090); + uint32_t _i1094; + for (_i1094 = 0; _i1094 < _size1090; ++_i1094) { - xfer += (*(this->success))[_i1095].read(iprot); + xfer += (*(this->success))[_i1094].read(iprot); } xfer += iprot->readListEnd(); } @@ -14966,14 +14966,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 _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - this->group_names.resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1095; + ::apache::thrift::protocol::TType _etype1098; + xfer += iprot->readListBegin(_etype1098, _size1095); + this->group_names.resize(_size1095); + uint32_t _i1099; + for (_i1099 = 0; _i1099 < _size1095; ++_i1099) { - xfer += iprot->readString(this->group_names[_i1100]); + xfer += iprot->readString(this->group_names[_i1099]); } xfer += iprot->readListEnd(); } @@ -15018,10 +15018,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 _iter1101; - for (_iter1101 = this->group_names.begin(); _iter1101 != this->group_names.end(); ++_iter1101) + std::vector ::const_iterator _iter1100; + for (_iter1100 = this->group_names.begin(); _iter1100 != this->group_names.end(); ++_iter1100) { - xfer += oprot->writeString((*_iter1101)); + xfer += oprot->writeString((*_iter1100)); } xfer += oprot->writeListEnd(); } @@ -15061,10 +15061,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 _iter1102; - for (_iter1102 = (*(this->group_names)).begin(); _iter1102 != (*(this->group_names)).end(); ++_iter1102) + std::vector ::const_iterator _iter1101; + for (_iter1101 = (*(this->group_names)).begin(); _iter1101 != (*(this->group_names)).end(); ++_iter1101) { - xfer += oprot->writeString((*_iter1102)); + xfer += oprot->writeString((*_iter1101)); } xfer += oprot->writeListEnd(); } @@ -15105,14 +15105,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->success.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1102; + ::apache::thrift::protocol::TType _etype1105; + xfer += iprot->readListBegin(_etype1105, _size1102); + this->success.resize(_size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - xfer += this->success[_i1107].read(iprot); + xfer += this->success[_i1106].read(iprot); } xfer += iprot->readListEnd(); } @@ -15159,10 +15159,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 _iter1108; - for (_iter1108 = this->success.begin(); _iter1108 != this->success.end(); ++_iter1108) + std::vector ::const_iterator _iter1107; + for (_iter1107 = this->success.begin(); _iter1107 != this->success.end(); ++_iter1107) { - xfer += (*_iter1108).write(oprot); + xfer += (*_iter1107).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15211,14 +15211,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1109; - ::apache::thrift::protocol::TType _etype1112; - xfer += iprot->readListBegin(_etype1112, _size1109); - (*(this->success)).resize(_size1109); - uint32_t _i1113; - for (_i1113 = 0; _i1113 < _size1109; ++_i1113) + uint32_t _size1108; + ::apache::thrift::protocol::TType _etype1111; + xfer += iprot->readListBegin(_etype1111, _size1108); + (*(this->success)).resize(_size1108); + uint32_t _i1112; + for (_i1112 = 0; _i1112 < _size1108; ++_i1112) { - xfer += (*(this->success))[_i1113].read(iprot); + xfer += (*(this->success))[_i1112].read(iprot); } xfer += iprot->readListEnd(); } @@ -15396,14 +15396,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - this->success.resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1113; + ::apache::thrift::protocol::TType _etype1116; + xfer += iprot->readListBegin(_etype1116, _size1113); + this->success.resize(_size1113); + uint32_t _i1117; + for (_i1117 = 0; _i1117 < _size1113; ++_i1117) { - xfer += this->success[_i1118].read(iprot); + xfer += this->success[_i1117].read(iprot); } xfer += iprot->readListEnd(); } @@ -15450,10 +15450,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 _iter1119; - for (_iter1119 = this->success.begin(); _iter1119 != this->success.end(); ++_iter1119) + std::vector ::const_iterator _iter1118; + for (_iter1118 = this->success.begin(); _iter1118 != this->success.end(); ++_iter1118) { - xfer += (*_iter1119).write(oprot); + xfer += (*_iter1118).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15502,14 +15502,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1120; - ::apache::thrift::protocol::TType _etype1123; - xfer += iprot->readListBegin(_etype1123, _size1120); - (*(this->success)).resize(_size1120); - uint32_t _i1124; - for (_i1124 = 0; _i1124 < _size1120; ++_i1124) + uint32_t _size1119; + ::apache::thrift::protocol::TType _etype1122; + xfer += iprot->readListBegin(_etype1122, _size1119); + (*(this->success)).resize(_size1119); + uint32_t _i1123; + for (_i1123 = 0; _i1123 < _size1119; ++_i1123) { - xfer += (*(this->success))[_i1124].read(iprot); + xfer += (*(this->success))[_i1123].read(iprot); } xfer += iprot->readListEnd(); } @@ -15687,14 +15687,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1125; - ::apache::thrift::protocol::TType _etype1128; - xfer += iprot->readListBegin(_etype1128, _size1125); - this->success.resize(_size1125); - uint32_t _i1129; - for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + uint32_t _size1124; + ::apache::thrift::protocol::TType _etype1127; + xfer += iprot->readListBegin(_etype1127, _size1124); + this->success.resize(_size1124); + uint32_t _i1128; + for (_i1128 = 0; _i1128 < _size1124; ++_i1128) { - xfer += iprot->readString(this->success[_i1129]); + xfer += iprot->readString(this->success[_i1128]); } xfer += iprot->readListEnd(); } @@ -15733,10 +15733,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 _iter1130; - for (_iter1130 = this->success.begin(); _iter1130 != this->success.end(); ++_iter1130) + std::vector ::const_iterator _iter1129; + for (_iter1129 = this->success.begin(); _iter1129 != this->success.end(); ++_iter1129) { - xfer += oprot->writeString((*_iter1130)); + xfer += oprot->writeString((*_iter1129)); } xfer += oprot->writeListEnd(); } @@ -15781,14 +15781,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - (*(this->success)).resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + 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))[_i1135]); + xfer += iprot->readString((*(this->success))[_i1134]); } xfer += iprot->readListEnd(); } @@ -15863,14 +15863,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 _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - this->part_vals.resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1135; + ::apache::thrift::protocol::TType _etype1138; + xfer += iprot->readListBegin(_etype1138, _size1135); + this->part_vals.resize(_size1135); + uint32_t _i1139; + for (_i1139 = 0; _i1139 < _size1135; ++_i1139) { - xfer += iprot->readString(this->part_vals[_i1140]); + xfer += iprot->readString(this->part_vals[_i1139]); } xfer += iprot->readListEnd(); } @@ -15915,10 +15915,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 _iter1141; - for (_iter1141 = this->part_vals.begin(); _iter1141 != this->part_vals.end(); ++_iter1141) + std::vector ::const_iterator _iter1140; + for (_iter1140 = this->part_vals.begin(); _iter1140 != this->part_vals.end(); ++_iter1140) { - xfer += oprot->writeString((*_iter1141)); + xfer += oprot->writeString((*_iter1140)); } xfer += oprot->writeListEnd(); } @@ -15954,10 +15954,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 _iter1142; - for (_iter1142 = (*(this->part_vals)).begin(); _iter1142 != (*(this->part_vals)).end(); ++_iter1142) + std::vector ::const_iterator _iter1141; + for (_iter1141 = (*(this->part_vals)).begin(); _iter1141 != (*(this->part_vals)).end(); ++_iter1141) { - xfer += oprot->writeString((*_iter1142)); + xfer += oprot->writeString((*_iter1141)); } xfer += oprot->writeListEnd(); } @@ -16002,14 +16002,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1143; - ::apache::thrift::protocol::TType _etype1146; - xfer += iprot->readListBegin(_etype1146, _size1143); - this->success.resize(_size1143); - uint32_t _i1147; - for (_i1147 = 0; _i1147 < _size1143; ++_i1147) + uint32_t _size1142; + ::apache::thrift::protocol::TType _etype1145; + xfer += iprot->readListBegin(_etype1145, _size1142); + this->success.resize(_size1142); + uint32_t _i1146; + for (_i1146 = 0; _i1146 < _size1142; ++_i1146) { - xfer += this->success[_i1147].read(iprot); + xfer += this->success[_i1146].read(iprot); } xfer += iprot->readListEnd(); } @@ -16056,10 +16056,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 _iter1148; - for (_iter1148 = this->success.begin(); _iter1148 != this->success.end(); ++_iter1148) + std::vector ::const_iterator _iter1147; + for (_iter1147 = this->success.begin(); _iter1147 != this->success.end(); ++_iter1147) { - xfer += (*_iter1148).write(oprot); + xfer += (*_iter1147).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16108,14 +16108,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1149; - ::apache::thrift::protocol::TType _etype1152; - xfer += iprot->readListBegin(_etype1152, _size1149); - (*(this->success)).resize(_size1149); - uint32_t _i1153; - for (_i1153 = 0; _i1153 < _size1149; ++_i1153) + uint32_t _size1148; + ::apache::thrift::protocol::TType _etype1151; + xfer += iprot->readListBegin(_etype1151, _size1148); + (*(this->success)).resize(_size1148); + uint32_t _i1152; + for (_i1152 = 0; _i1152 < _size1148; ++_i1152) { - xfer += (*(this->success))[_i1153].read(iprot); + xfer += (*(this->success))[_i1152].read(iprot); } xfer += iprot->readListEnd(); } @@ -16198,14 +16198,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 _size1154; - ::apache::thrift::protocol::TType _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - this->part_vals.resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1153; + ::apache::thrift::protocol::TType _etype1156; + xfer += iprot->readListBegin(_etype1156, _size1153); + this->part_vals.resize(_size1153); + uint32_t _i1157; + for (_i1157 = 0; _i1157 < _size1153; ++_i1157) { - xfer += iprot->readString(this->part_vals[_i1158]); + xfer += iprot->readString(this->part_vals[_i1157]); } xfer += iprot->readListEnd(); } @@ -16234,14 +16234,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 _size1159; - ::apache::thrift::protocol::TType _etype1162; - xfer += iprot->readListBegin(_etype1162, _size1159); - this->group_names.resize(_size1159); - uint32_t _i1163; - for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + uint32_t _size1158; + ::apache::thrift::protocol::TType _etype1161; + xfer += iprot->readListBegin(_etype1161, _size1158); + this->group_names.resize(_size1158); + uint32_t _i1162; + for (_i1162 = 0; _i1162 < _size1158; ++_i1162) { - xfer += iprot->readString(this->group_names[_i1163]); + xfer += iprot->readString(this->group_names[_i1162]); } xfer += iprot->readListEnd(); } @@ -16278,10 +16278,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 _iter1164; - for (_iter1164 = this->part_vals.begin(); _iter1164 != this->part_vals.end(); ++_iter1164) + std::vector ::const_iterator _iter1163; + for (_iter1163 = this->part_vals.begin(); _iter1163 != this->part_vals.end(); ++_iter1163) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1163)); } xfer += oprot->writeListEnd(); } @@ -16298,10 +16298,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 _iter1165; - for (_iter1165 = this->group_names.begin(); _iter1165 != this->group_names.end(); ++_iter1165) + std::vector ::const_iterator _iter1164; + for (_iter1164 = this->group_names.begin(); _iter1164 != this->group_names.end(); ++_iter1164) { - xfer += oprot->writeString((*_iter1165)); + xfer += oprot->writeString((*_iter1164)); } xfer += oprot->writeListEnd(); } @@ -16333,10 +16333,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 _iter1166; - for (_iter1166 = (*(this->part_vals)).begin(); _iter1166 != (*(this->part_vals)).end(); ++_iter1166) + std::vector ::const_iterator _iter1165; + for (_iter1165 = (*(this->part_vals)).begin(); _iter1165 != (*(this->part_vals)).end(); ++_iter1165) { - xfer += oprot->writeString((*_iter1166)); + xfer += oprot->writeString((*_iter1165)); } xfer += oprot->writeListEnd(); } @@ -16353,10 +16353,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 _iter1167; - for (_iter1167 = (*(this->group_names)).begin(); _iter1167 != (*(this->group_names)).end(); ++_iter1167) + std::vector ::const_iterator _iter1166; + for (_iter1166 = (*(this->group_names)).begin(); _iter1166 != (*(this->group_names)).end(); ++_iter1166) { - xfer += oprot->writeString((*_iter1167)); + xfer += oprot->writeString((*_iter1166)); } xfer += oprot->writeListEnd(); } @@ -16397,14 +16397,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: 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 _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + this->success.resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += this->success[_i1172].read(iprot); + xfer += this->success[_i1171].read(iprot); } xfer += iprot->readListEnd(); } @@ -16451,10 +16451,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 _iter1173; - for (_iter1173 = this->success.begin(); _iter1173 != this->success.end(); ++_iter1173) + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->success.begin(); _iter1172 != this->success.end(); ++_iter1172) { - xfer += (*_iter1173).write(oprot); + xfer += (*_iter1172).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16503,14 +16503,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: 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 _size1173; + ::apache::thrift::protocol::TType _etype1176; + xfer += iprot->readListBegin(_etype1176, _size1173); + (*(this->success)).resize(_size1173); + uint32_t _i1177; + for (_i1177 = 0; _i1177 < _size1173; ++_i1177) { - xfer += (*(this->success))[_i1178].read(iprot); + xfer += (*(this->success))[_i1177].read(iprot); } xfer += iprot->readListEnd(); } @@ -16593,14 +16593,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 _size1179; - ::apache::thrift::protocol::TType _etype1182; - xfer += iprot->readListBegin(_etype1182, _size1179); - this->part_vals.resize(_size1179); - uint32_t _i1183; - for (_i1183 = 0; _i1183 < _size1179; ++_i1183) + uint32_t _size1178; + ::apache::thrift::protocol::TType _etype1181; + xfer += iprot->readListBegin(_etype1181, _size1178); + this->part_vals.resize(_size1178); + uint32_t _i1182; + for (_i1182 = 0; _i1182 < _size1178; ++_i1182) { - xfer += iprot->readString(this->part_vals[_i1183]); + xfer += iprot->readString(this->part_vals[_i1182]); } xfer += iprot->readListEnd(); } @@ -16645,10 +16645,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 _iter1184; - for (_iter1184 = this->part_vals.begin(); _iter1184 != this->part_vals.end(); ++_iter1184) + std::vector ::const_iterator _iter1183; + for (_iter1183 = this->part_vals.begin(); _iter1183 != this->part_vals.end(); ++_iter1183) { - xfer += oprot->writeString((*_iter1184)); + xfer += oprot->writeString((*_iter1183)); } xfer += oprot->writeListEnd(); } @@ -16684,10 +16684,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 _iter1185; - for (_iter1185 = (*(this->part_vals)).begin(); _iter1185 != (*(this->part_vals)).end(); ++_iter1185) + std::vector ::const_iterator _iter1184; + for (_iter1184 = (*(this->part_vals)).begin(); _iter1184 != (*(this->part_vals)).end(); ++_iter1184) { - xfer += oprot->writeString((*_iter1185)); + xfer += oprot->writeString((*_iter1184)); } xfer += oprot->writeListEnd(); } @@ -16732,14 +16732,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1186; - ::apache::thrift::protocol::TType _etype1189; - xfer += iprot->readListBegin(_etype1189, _size1186); - this->success.resize(_size1186); - uint32_t _i1190; - for (_i1190 = 0; _i1190 < _size1186; ++_i1190) + uint32_t _size1185; + ::apache::thrift::protocol::TType _etype1188; + xfer += iprot->readListBegin(_etype1188, _size1185); + this->success.resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += iprot->readString(this->success[_i1190]); + xfer += iprot->readString(this->success[_i1189]); } xfer += iprot->readListEnd(); } @@ -16786,10 +16786,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 _iter1191; - for (_iter1191 = this->success.begin(); _iter1191 != this->success.end(); ++_iter1191) + std::vector ::const_iterator _iter1190; + for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1190)); } xfer += oprot->writeListEnd(); } @@ -16838,14 +16838,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1192; - ::apache::thrift::protocol::TType _etype1195; - xfer += iprot->readListBegin(_etype1195, _size1192); - (*(this->success)).resize(_size1192); - uint32_t _i1196; - for (_i1196 = 0; _i1196 < _size1192; ++_i1196) + uint32_t _size1191; + ::apache::thrift::protocol::TType _etype1194; + xfer += iprot->readListBegin(_etype1194, _size1191); + (*(this->success)).resize(_size1191); + uint32_t _i1195; + for (_i1195 = 0; _i1195 < _size1191; ++_i1195) { - xfer += iprot->readString((*(this->success))[_i1196]); + xfer += iprot->readString((*(this->success))[_i1195]); } xfer += iprot->readListEnd(); } @@ -17039,14 +17039,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - this->success.resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + uint32_t _size1196; + ::apache::thrift::protocol::TType _etype1199; + xfer += iprot->readListBegin(_etype1199, _size1196); + this->success.resize(_size1196); + uint32_t _i1200; + for (_i1200 = 0; _i1200 < _size1196; ++_i1200) { - xfer += this->success[_i1201].read(iprot); + xfer += this->success[_i1200].read(iprot); } xfer += iprot->readListEnd(); } @@ -17093,10 +17093,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 _iter1202; - for (_iter1202 = this->success.begin(); _iter1202 != this->success.end(); ++_iter1202) + std::vector ::const_iterator _iter1201; + for (_iter1201 = this->success.begin(); _iter1201 != this->success.end(); ++_iter1201) { - xfer += (*_iter1202).write(oprot); + xfer += (*_iter1201).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17145,14 +17145,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1203; - ::apache::thrift::protocol::TType _etype1206; - xfer += iprot->readListBegin(_etype1206, _size1203); - (*(this->success)).resize(_size1203); - uint32_t _i1207; - for (_i1207 = 0; _i1207 < _size1203; ++_i1207) + uint32_t _size1202; + ::apache::thrift::protocol::TType _etype1205; + xfer += iprot->readListBegin(_etype1205, _size1202); + (*(this->success)).resize(_size1202); + uint32_t _i1206; + for (_i1206 = 0; _i1206 < _size1202; ++_i1206) { - xfer += (*(this->success))[_i1207].read(iprot); + xfer += (*(this->success))[_i1206].read(iprot); } xfer += iprot->readListEnd(); } @@ -17346,14 +17346,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 _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - this->success.resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + 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) { - xfer += this->success[_i1212].read(iprot); + xfer += this->success[_i1211].read(iprot); } xfer += iprot->readListEnd(); } @@ -17400,10 +17400,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 _iter1213; - for (_iter1213 = this->success.begin(); _iter1213 != this->success.end(); ++_iter1213) + std::vector ::const_iterator _iter1212; + for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212) { - xfer += (*_iter1213).write(oprot); + xfer += (*_iter1212).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17452,14 +17452,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 _size1214; - ::apache::thrift::protocol::TType _etype1217; - xfer += iprot->readListBegin(_etype1217, _size1214); - (*(this->success)).resize(_size1214); - uint32_t _i1218; - for (_i1218 = 0; _i1218 < _size1214; ++_i1218) + 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) { - xfer += (*(this->success))[_i1218].read(iprot); + xfer += (*(this->success))[_i1217].read(iprot); } xfer += iprot->readListEnd(); } @@ -18028,14 +18028,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - this->names.resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1218; + ::apache::thrift::protocol::TType _etype1221; + xfer += iprot->readListBegin(_etype1221, _size1218); + this->names.resize(_size1218); + uint32_t _i1222; + for (_i1222 = 0; _i1222 < _size1218; ++_i1222) { - xfer += iprot->readString(this->names[_i1223]); + xfer += iprot->readString(this->names[_i1222]); } xfer += iprot->readListEnd(); } @@ -18072,10 +18072,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 _iter1224; - for (_iter1224 = this->names.begin(); _iter1224 != this->names.end(); ++_iter1224) + std::vector ::const_iterator _iter1223; + for (_iter1223 = this->names.begin(); _iter1223 != this->names.end(); ++_iter1223) { - xfer += oprot->writeString((*_iter1224)); + xfer += oprot->writeString((*_iter1223)); } xfer += oprot->writeListEnd(); } @@ -18107,10 +18107,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 _iter1225; - for (_iter1225 = (*(this->names)).begin(); _iter1225 != (*(this->names)).end(); ++_iter1225) + std::vector ::const_iterator _iter1224; + for (_iter1224 = (*(this->names)).begin(); _iter1224 != (*(this->names)).end(); ++_iter1224) { - xfer += oprot->writeString((*_iter1225)); + xfer += oprot->writeString((*_iter1224)); } xfer += oprot->writeListEnd(); } @@ -18151,14 +18151,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1226; - ::apache::thrift::protocol::TType _etype1229; - xfer += iprot->readListBegin(_etype1229, _size1226); - this->success.resize(_size1226); - uint32_t _i1230; - for (_i1230 = 0; _i1230 < _size1226; ++_i1230) + uint32_t _size1225; + ::apache::thrift::protocol::TType _etype1228; + xfer += iprot->readListBegin(_etype1228, _size1225); + this->success.resize(_size1225); + uint32_t _i1229; + for (_i1229 = 0; _i1229 < _size1225; ++_i1229) { - xfer += this->success[_i1230].read(iprot); + xfer += this->success[_i1229].read(iprot); } xfer += iprot->readListEnd(); } @@ -18205,10 +18205,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 _iter1231; - for (_iter1231 = this->success.begin(); _iter1231 != this->success.end(); ++_iter1231) + std::vector ::const_iterator _iter1230; + for (_iter1230 = this->success.begin(); _iter1230 != this->success.end(); ++_iter1230) { - xfer += (*_iter1231).write(oprot); + xfer += (*_iter1230).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18257,14 +18257,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1232; - ::apache::thrift::protocol::TType _etype1235; - xfer += iprot->readListBegin(_etype1235, _size1232); - (*(this->success)).resize(_size1232); - uint32_t _i1236; - for (_i1236 = 0; _i1236 < _size1232; ++_i1236) + uint32_t _size1231; + ::apache::thrift::protocol::TType _etype1234; + xfer += iprot->readListBegin(_etype1234, _size1231); + (*(this->success)).resize(_size1231); + uint32_t _i1235; + for (_i1235 = 0; _i1235 < _size1231; ++_i1235) { - xfer += (*(this->success))[_i1236].read(iprot); + xfer += (*(this->success))[_i1235].read(iprot); } xfer += iprot->readListEnd(); } @@ -18586,14 +18586,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - this->new_parts.resize(_size1237); - uint32_t _i1241; - for (_i1241 = 0; _i1241 < _size1237; ++_i1241) + uint32_t _size1236; + ::apache::thrift::protocol::TType _etype1239; + xfer += iprot->readListBegin(_etype1239, _size1236); + this->new_parts.resize(_size1236); + uint32_t _i1240; + for (_i1240 = 0; _i1240 < _size1236; ++_i1240) { - xfer += this->new_parts[_i1241].read(iprot); + xfer += this->new_parts[_i1240].read(iprot); } xfer += iprot->readListEnd(); } @@ -18630,10 +18630,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 _iter1242; - for (_iter1242 = this->new_parts.begin(); _iter1242 != this->new_parts.end(); ++_iter1242) + std::vector ::const_iterator _iter1241; + for (_iter1241 = this->new_parts.begin(); _iter1241 != this->new_parts.end(); ++_iter1241) { - xfer += (*_iter1242).write(oprot); + xfer += (*_iter1241).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18665,10 +18665,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 _iter1243; - for (_iter1243 = (*(this->new_parts)).begin(); _iter1243 != (*(this->new_parts)).end(); ++_iter1243) + std::vector ::const_iterator _iter1242; + for (_iter1242 = (*(this->new_parts)).begin(); _iter1242 != (*(this->new_parts)).end(); ++_iter1242) { - xfer += (*_iter1243).write(oprot); + xfer += (*_iter1242).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18853,14 +18853,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1244; - ::apache::thrift::protocol::TType _etype1247; - xfer += iprot->readListBegin(_etype1247, _size1244); - this->new_parts.resize(_size1244); - uint32_t _i1248; - for (_i1248 = 0; _i1248 < _size1244; ++_i1248) + uint32_t _size1243; + ::apache::thrift::protocol::TType _etype1246; + xfer += iprot->readListBegin(_etype1246, _size1243); + this->new_parts.resize(_size1243); + uint32_t _i1247; + for (_i1247 = 0; _i1247 < _size1243; ++_i1247) { - xfer += this->new_parts[_i1248].read(iprot); + xfer += this->new_parts[_i1247].read(iprot); } xfer += iprot->readListEnd(); } @@ -18905,10 +18905,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 _iter1249; - for (_iter1249 = this->new_parts.begin(); _iter1249 != this->new_parts.end(); ++_iter1249) + std::vector ::const_iterator _iter1248; + for (_iter1248 = this->new_parts.begin(); _iter1248 != this->new_parts.end(); ++_iter1248) { - xfer += (*_iter1249).write(oprot); + xfer += (*_iter1248).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18944,10 +18944,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 _iter1250; - for (_iter1250 = (*(this->new_parts)).begin(); _iter1250 != (*(this->new_parts)).end(); ++_iter1250) + std::vector ::const_iterator _iter1249; + for (_iter1249 = (*(this->new_parts)).begin(); _iter1249 != (*(this->new_parts)).end(); ++_iter1249) { - xfer += (*_iter1250).write(oprot); + xfer += (*_iter1249).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19391,14 +19391,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - this->part_vals.resize(_size1251); - uint32_t _i1255; - for (_i1255 = 0; _i1255 < _size1251; ++_i1255) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->part_vals.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString(this->part_vals[_i1255]); + xfer += iprot->readString(this->part_vals[_i1254]); } xfer += iprot->readListEnd(); } @@ -19443,10 +19443,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 _iter1256; - for (_iter1256 = this->part_vals.begin(); _iter1256 != this->part_vals.end(); ++_iter1256) + std::vector ::const_iterator _iter1255; + for (_iter1255 = this->part_vals.begin(); _iter1255 != this->part_vals.end(); ++_iter1255) { - xfer += oprot->writeString((*_iter1256)); + xfer += oprot->writeString((*_iter1255)); } xfer += oprot->writeListEnd(); } @@ -19482,10 +19482,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 _iter1257; - for (_iter1257 = (*(this->part_vals)).begin(); _iter1257 != (*(this->part_vals)).end(); ++_iter1257) + std::vector ::const_iterator _iter1256; + for (_iter1256 = (*(this->part_vals)).begin(); _iter1256 != (*(this->part_vals)).end(); ++_iter1256) { - xfer += oprot->writeString((*_iter1257)); + xfer += oprot->writeString((*_iter1256)); } xfer += oprot->writeListEnd(); } @@ -19658,14 +19658,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 _size1258; - ::apache::thrift::protocol::TType _etype1261; - xfer += iprot->readListBegin(_etype1261, _size1258); - this->part_vals.resize(_size1258); - uint32_t _i1262; - for (_i1262 = 0; _i1262 < _size1258; ++_i1262) + uint32_t _size1257; + ::apache::thrift::protocol::TType _etype1260; + xfer += iprot->readListBegin(_etype1260, _size1257); + this->part_vals.resize(_size1257); + uint32_t _i1261; + for (_i1261 = 0; _i1261 < _size1257; ++_i1261) { - xfer += iprot->readString(this->part_vals[_i1262]); + xfer += iprot->readString(this->part_vals[_i1261]); } xfer += iprot->readListEnd(); } @@ -19702,10 +19702,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 _iter1263; - for (_iter1263 = this->part_vals.begin(); _iter1263 != this->part_vals.end(); ++_iter1263) + std::vector ::const_iterator _iter1262; + for (_iter1262 = this->part_vals.begin(); _iter1262 != this->part_vals.end(); ++_iter1262) { - xfer += oprot->writeString((*_iter1263)); + xfer += oprot->writeString((*_iter1262)); } xfer += oprot->writeListEnd(); } @@ -19733,10 +19733,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 _iter1264; - for (_iter1264 = (*(this->part_vals)).begin(); _iter1264 != (*(this->part_vals)).end(); ++_iter1264) + std::vector ::const_iterator _iter1263; + for (_iter1263 = (*(this->part_vals)).begin(); _iter1263 != (*(this->part_vals)).end(); ++_iter1263) { - xfer += oprot->writeString((*_iter1264)); + xfer += oprot->writeString((*_iter1263)); } xfer += oprot->writeListEnd(); } @@ -20211,14 +20211,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1265; - ::apache::thrift::protocol::TType _etype1268; - xfer += iprot->readListBegin(_etype1268, _size1265); - this->success.resize(_size1265); - uint32_t _i1269; - for (_i1269 = 0; _i1269 < _size1265; ++_i1269) + 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) { - xfer += iprot->readString(this->success[_i1269]); + xfer += iprot->readString(this->success[_i1268]); } xfer += iprot->readListEnd(); } @@ -20257,10 +20257,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 _iter1270; - for (_iter1270 = this->success.begin(); _iter1270 != this->success.end(); ++_iter1270) + std::vector ::const_iterator _iter1269; + for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) { - xfer += oprot->writeString((*_iter1270)); + xfer += oprot->writeString((*_iter1269)); } xfer += oprot->writeListEnd(); } @@ -20305,14 +20305,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1271; - ::apache::thrift::protocol::TType _etype1274; - xfer += iprot->readListBegin(_etype1274, _size1271); - (*(this->success)).resize(_size1271); - uint32_t _i1275; - for (_i1275 = 0; _i1275 < _size1271; ++_i1275) + 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) { - xfer += iprot->readString((*(this->success))[_i1275]); + xfer += iprot->readString((*(this->success))[_i1274]); } xfer += iprot->readListEnd(); } @@ -20450,17 +20450,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1276; - ::apache::thrift::protocol::TType _ktype1277; - ::apache::thrift::protocol::TType _vtype1278; - xfer += iprot->readMapBegin(_ktype1277, _vtype1278, _size1276); - uint32_t _i1280; - for (_i1280 = 0; _i1280 < _size1276; ++_i1280) + uint32_t _size1275; + ::apache::thrift::protocol::TType _ktype1276; + ::apache::thrift::protocol::TType _vtype1277; + xfer += iprot->readMapBegin(_ktype1276, _vtype1277, _size1275); + uint32_t _i1279; + for (_i1279 = 0; _i1279 < _size1275; ++_i1279) { - std::string _key1281; - xfer += iprot->readString(_key1281); - std::string& _val1282 = this->success[_key1281]; - xfer += iprot->readString(_val1282); + std::string _key1280; + xfer += iprot->readString(_key1280); + std::string& _val1281 = this->success[_key1280]; + xfer += iprot->readString(_val1281); } xfer += iprot->readMapEnd(); } @@ -20499,11 +20499,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 _iter1283; - for (_iter1283 = this->success.begin(); _iter1283 != this->success.end(); ++_iter1283) + std::map ::const_iterator _iter1282; + for (_iter1282 = this->success.begin(); _iter1282 != this->success.end(); ++_iter1282) { - xfer += oprot->writeString(_iter1283->first); - xfer += oprot->writeString(_iter1283->second); + xfer += oprot->writeString(_iter1282->first); + xfer += oprot->writeString(_iter1282->second); } xfer += oprot->writeMapEnd(); } @@ -20548,17 +20548,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1284; - ::apache::thrift::protocol::TType _ktype1285; - ::apache::thrift::protocol::TType _vtype1286; - xfer += iprot->readMapBegin(_ktype1285, _vtype1286, _size1284); - uint32_t _i1288; - for (_i1288 = 0; _i1288 < _size1284; ++_i1288) + uint32_t _size1283; + ::apache::thrift::protocol::TType _ktype1284; + ::apache::thrift::protocol::TType _vtype1285; + xfer += iprot->readMapBegin(_ktype1284, _vtype1285, _size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - std::string _key1289; - xfer += iprot->readString(_key1289); - std::string& _val1290 = (*(this->success))[_key1289]; - xfer += iprot->readString(_val1290); + std::string _key1288; + xfer += iprot->readString(_key1288); + std::string& _val1289 = (*(this->success))[_key1288]; + xfer += iprot->readString(_val1289); } xfer += iprot->readMapEnd(); } @@ -20633,17 +20633,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _ktype1292; - ::apache::thrift::protocol::TType _vtype1293; - xfer += iprot->readMapBegin(_ktype1292, _vtype1293, _size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1290; + ::apache::thrift::protocol::TType _ktype1291; + ::apache::thrift::protocol::TType _vtype1292; + xfer += iprot->readMapBegin(_ktype1291, _vtype1292, _size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - std::string _key1296; - xfer += iprot->readString(_key1296); - std::string& _val1297 = this->part_vals[_key1296]; - xfer += iprot->readString(_val1297); + std::string _key1295; + xfer += iprot->readString(_key1295); + std::string& _val1296 = this->part_vals[_key1295]; + xfer += iprot->readString(_val1296); } xfer += iprot->readMapEnd(); } @@ -20654,9 +20654,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1298; - xfer += iprot->readI32(ecast1298); - this->eventType = (PartitionEventType::type)ecast1298; + int32_t ecast1297; + xfer += iprot->readI32(ecast1297); + this->eventType = (PartitionEventType::type)ecast1297; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20690,11 +20690,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 _iter1299; - for (_iter1299 = this->part_vals.begin(); _iter1299 != this->part_vals.end(); ++_iter1299) + std::map ::const_iterator _iter1298; + for (_iter1298 = this->part_vals.begin(); _iter1298 != this->part_vals.end(); ++_iter1298) { - xfer += oprot->writeString(_iter1299->first); - xfer += oprot->writeString(_iter1299->second); + xfer += oprot->writeString(_iter1298->first); + xfer += oprot->writeString(_iter1298->second); } xfer += oprot->writeMapEnd(); } @@ -20730,11 +20730,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 _iter1300; - for (_iter1300 = (*(this->part_vals)).begin(); _iter1300 != (*(this->part_vals)).end(); ++_iter1300) + std::map ::const_iterator _iter1299; + for (_iter1299 = (*(this->part_vals)).begin(); _iter1299 != (*(this->part_vals)).end(); ++_iter1299) { - xfer += oprot->writeString(_iter1300->first); - xfer += oprot->writeString(_iter1300->second); + xfer += oprot->writeString(_iter1299->first); + xfer += oprot->writeString(_iter1299->second); } xfer += oprot->writeMapEnd(); } @@ -21003,17 +21003,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1301; - ::apache::thrift::protocol::TType _ktype1302; - ::apache::thrift::protocol::TType _vtype1303; - xfer += iprot->readMapBegin(_ktype1302, _vtype1303, _size1301); - uint32_t _i1305; - for (_i1305 = 0; _i1305 < _size1301; ++_i1305) + uint32_t _size1300; + ::apache::thrift::protocol::TType _ktype1301; + ::apache::thrift::protocol::TType _vtype1302; + xfer += iprot->readMapBegin(_ktype1301, _vtype1302, _size1300); + uint32_t _i1304; + for (_i1304 = 0; _i1304 < _size1300; ++_i1304) { - std::string _key1306; - xfer += iprot->readString(_key1306); - std::string& _val1307 = this->part_vals[_key1306]; - xfer += iprot->readString(_val1307); + std::string _key1305; + xfer += iprot->readString(_key1305); + std::string& _val1306 = this->part_vals[_key1305]; + xfer += iprot->readString(_val1306); } xfer += iprot->readMapEnd(); } @@ -21024,9 +21024,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1308; - xfer += iprot->readI32(ecast1308); - this->eventType = (PartitionEventType::type)ecast1308; + int32_t ecast1307; + xfer += iprot->readI32(ecast1307); + this->eventType = (PartitionEventType::type)ecast1307; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21060,11 +21060,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 _iter1309; - for (_iter1309 = this->part_vals.begin(); _iter1309 != this->part_vals.end(); ++_iter1309) + std::map ::const_iterator _iter1308; + for (_iter1308 = this->part_vals.begin(); _iter1308 != this->part_vals.end(); ++_iter1308) { - xfer += oprot->writeString(_iter1309->first); - xfer += oprot->writeString(_iter1309->second); + xfer += oprot->writeString(_iter1308->first); + xfer += oprot->writeString(_iter1308->second); } xfer += oprot->writeMapEnd(); } @@ -21100,11 +21100,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 _iter1310; - for (_iter1310 = (*(this->part_vals)).begin(); _iter1310 != (*(this->part_vals)).end(); ++_iter1310) + std::map ::const_iterator _iter1309; + for (_iter1309 = (*(this->part_vals)).begin(); _iter1309 != (*(this->part_vals)).end(); ++_iter1309) { - xfer += oprot->writeString(_iter1310->first); - xfer += oprot->writeString(_iter1310->second); + xfer += oprot->writeString(_iter1309->first); + xfer += oprot->writeString(_iter1309->second); } xfer += oprot->writeMapEnd(); } @@ -22540,14 +22540,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1311; - ::apache::thrift::protocol::TType _etype1314; - xfer += iprot->readListBegin(_etype1314, _size1311); - this->success.resize(_size1311); - uint32_t _i1315; - for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + uint32_t _size1310; + ::apache::thrift::protocol::TType _etype1313; + xfer += iprot->readListBegin(_etype1313, _size1310); + this->success.resize(_size1310); + uint32_t _i1314; + for (_i1314 = 0; _i1314 < _size1310; ++_i1314) { - xfer += this->success[_i1315].read(iprot); + xfer += this->success[_i1314].read(iprot); } xfer += iprot->readListEnd(); } @@ -22594,10 +22594,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 _iter1316; - for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316) + std::vector ::const_iterator _iter1315; + for (_iter1315 = this->success.begin(); _iter1315 != this->success.end(); ++_iter1315) { - xfer += (*_iter1316).write(oprot); + xfer += (*_iter1315).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22646,14 +22646,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1317; - ::apache::thrift::protocol::TType _etype1320; - xfer += iprot->readListBegin(_etype1320, _size1317); - (*(this->success)).resize(_size1317); - uint32_t _i1321; - for (_i1321 = 0; _i1321 < _size1317; ++_i1321) + uint32_t _size1316; + ::apache::thrift::protocol::TType _etype1319; + xfer += iprot->readListBegin(_etype1319, _size1316); + (*(this->success)).resize(_size1316); + uint32_t _i1320; + for (_i1320 = 0; _i1320 < _size1316; ++_i1320) { - xfer += (*(this->success))[_i1321].read(iprot); + xfer += (*(this->success))[_i1320].read(iprot); } xfer += iprot->readListEnd(); } @@ -22831,14 +22831,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1321; + ::apache::thrift::protocol::TType _etype1324; + xfer += iprot->readListBegin(_etype1324, _size1321); + this->success.resize(_size1321); + uint32_t _i1325; + for (_i1325 = 0; _i1325 < _size1321; ++_i1325) { - xfer += iprot->readString(this->success[_i1326]); + xfer += iprot->readString(this->success[_i1325]); } xfer += iprot->readListEnd(); } @@ -22877,10 +22877,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 _iter1327; - for (_iter1327 = this->success.begin(); _iter1327 != this->success.end(); ++_iter1327) + std::vector ::const_iterator _iter1326; + for (_iter1326 = this->success.begin(); _iter1326 != this->success.end(); ++_iter1326) { - xfer += oprot->writeString((*_iter1327)); + xfer += oprot->writeString((*_iter1326)); } xfer += oprot->writeListEnd(); } @@ -22925,14 +22925,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1327; + ::apache::thrift::protocol::TType _etype1330; + xfer += iprot->readListBegin(_etype1330, _size1327); + (*(this->success)).resize(_size1327); + uint32_t _i1331; + for (_i1331 = 0; _i1331 < _size1327; ++_i1331) { - xfer += iprot->readString((*(this->success))[_i1332]); + xfer += iprot->readString((*(this->success))[_i1331]); } xfer += iprot->readListEnd(); } @@ -26959,14 +26959,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1333; - ::apache::thrift::protocol::TType _etype1336; - xfer += iprot->readListBegin(_etype1336, _size1333); - this->success.resize(_size1333); - uint32_t _i1337; - for (_i1337 = 0; _i1337 < _size1333; ++_i1337) + uint32_t _size1332; + ::apache::thrift::protocol::TType _etype1335; + xfer += iprot->readListBegin(_etype1335, _size1332); + this->success.resize(_size1332); + uint32_t _i1336; + for (_i1336 = 0; _i1336 < _size1332; ++_i1336) { - xfer += iprot->readString(this->success[_i1337]); + xfer += iprot->readString(this->success[_i1336]); } xfer += iprot->readListEnd(); } @@ -27005,10 +27005,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 _iter1338; - for (_iter1338 = this->success.begin(); _iter1338 != this->success.end(); ++_iter1338) + std::vector ::const_iterator _iter1337; + for (_iter1337 = this->success.begin(); _iter1337 != this->success.end(); ++_iter1337) { - xfer += oprot->writeString((*_iter1338)); + xfer += oprot->writeString((*_iter1337)); } xfer += oprot->writeListEnd(); } @@ -27053,14 +27053,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1339; - ::apache::thrift::protocol::TType _etype1342; - xfer += iprot->readListBegin(_etype1342, _size1339); - (*(this->success)).resize(_size1339); - uint32_t _i1343; - for (_i1343 = 0; _i1343 < _size1339; ++_i1343) + 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) { - xfer += iprot->readString((*(this->success))[_i1343]); + xfer += iprot->readString((*(this->success))[_i1342]); } xfer += iprot->readListEnd(); } @@ -28020,14 +28020,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto 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 _size1343; + ::apache::thrift::protocol::TType _etype1346; + xfer += iprot->readListBegin(_etype1346, _size1343); + this->success.resize(_size1343); + uint32_t _i1347; + for (_i1347 = 0; _i1347 < _size1343; ++_i1347) { - xfer += iprot->readString(this->success[_i1348]); + xfer += iprot->readString(this->success[_i1347]); } xfer += iprot->readListEnd(); } @@ -28066,10 +28066,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 _iter1349; - for (_iter1349 = this->success.begin(); _iter1349 != this->success.end(); ++_iter1349) + std::vector ::const_iterator _iter1348; + for (_iter1348 = this->success.begin(); _iter1348 != this->success.end(); ++_iter1348) { - xfer += oprot->writeString((*_iter1349)); + xfer += oprot->writeString((*_iter1348)); } xfer += oprot->writeListEnd(); } @@ -28114,14 +28114,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1350; - ::apache::thrift::protocol::TType _etype1353; - xfer += iprot->readListBegin(_etype1353, _size1350); - (*(this->success)).resize(_size1350); - uint32_t _i1354; - for (_i1354 = 0; _i1354 < _size1350; ++_i1354) + 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) { - xfer += iprot->readString((*(this->success))[_i1354]); + xfer += iprot->readString((*(this->success))[_i1353]); } xfer += iprot->readListEnd(); } @@ -28194,9 +28194,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1355; - xfer += iprot->readI32(ecast1355); - this->principal_type = (PrincipalType::type)ecast1355; + int32_t ecast1354; + xfer += iprot->readI32(ecast1354); + this->principal_type = (PrincipalType::type)ecast1354; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28212,9 +28212,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1356; - xfer += iprot->readI32(ecast1356); - this->grantorType = (PrincipalType::type)ecast1356; + int32_t ecast1355; + xfer += iprot->readI32(ecast1355); + this->grantorType = (PrincipalType::type)ecast1355; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -28485,9 +28485,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1357; - xfer += iprot->readI32(ecast1357); - this->principal_type = (PrincipalType::type)ecast1357; + int32_t ecast1356; + xfer += iprot->readI32(ecast1356); + this->principal_type = (PrincipalType::type)ecast1356; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28718,9 +28718,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1358; - xfer += iprot->readI32(ecast1358); - this->principal_type = (PrincipalType::type)ecast1358; + int32_t ecast1357; + xfer += iprot->readI32(ecast1357); + this->principal_type = (PrincipalType::type)ecast1357; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28809,14 +28809,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1359; - ::apache::thrift::protocol::TType _etype1362; - xfer += iprot->readListBegin(_etype1362, _size1359); - this->success.resize(_size1359); - uint32_t _i1363; - for (_i1363 = 0; _i1363 < _size1359; ++_i1363) + uint32_t _size1358; + ::apache::thrift::protocol::TType _etype1361; + xfer += iprot->readListBegin(_etype1361, _size1358); + this->success.resize(_size1358); + uint32_t _i1362; + for (_i1362 = 0; _i1362 < _size1358; ++_i1362) { - xfer += this->success[_i1363].read(iprot); + xfer += this->success[_i1362].read(iprot); } xfer += iprot->readListEnd(); } @@ -28855,10 +28855,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 _iter1364; - for (_iter1364 = this->success.begin(); _iter1364 != this->success.end(); ++_iter1364) + std::vector ::const_iterator _iter1363; + for (_iter1363 = this->success.begin(); _iter1363 != this->success.end(); ++_iter1363) { - xfer += (*_iter1364).write(oprot); + xfer += (*_iter1363).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28903,14 +28903,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1365; - ::apache::thrift::protocol::TType _etype1368; - xfer += iprot->readListBegin(_etype1368, _size1365); - (*(this->success)).resize(_size1365); - uint32_t _i1369; - for (_i1369 = 0; _i1369 < _size1365; ++_i1369) + uint32_t _size1364; + ::apache::thrift::protocol::TType _etype1367; + xfer += iprot->readListBegin(_etype1367, _size1364); + (*(this->success)).resize(_size1364); + uint32_t _i1368; + for (_i1368 = 0; _i1368 < _size1364; ++_i1368) { - xfer += (*(this->success))[_i1369].read(iprot); + xfer += (*(this->success))[_i1368].read(iprot); } xfer += iprot->readListEnd(); } @@ -29606,14 +29606,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 _size1370; - ::apache::thrift::protocol::TType _etype1373; - xfer += iprot->readListBegin(_etype1373, _size1370); - this->group_names.resize(_size1370); - uint32_t _i1374; - for (_i1374 = 0; _i1374 < _size1370; ++_i1374) + uint32_t _size1369; + ::apache::thrift::protocol::TType _etype1372; + xfer += iprot->readListBegin(_etype1372, _size1369); + this->group_names.resize(_size1369); + uint32_t _i1373; + for (_i1373 = 0; _i1373 < _size1369; ++_i1373) { - xfer += iprot->readString(this->group_names[_i1374]); + xfer += iprot->readString(this->group_names[_i1373]); } xfer += iprot->readListEnd(); } @@ -29650,10 +29650,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 _iter1375; - for (_iter1375 = this->group_names.begin(); _iter1375 != this->group_names.end(); ++_iter1375) + std::vector ::const_iterator _iter1374; + for (_iter1374 = this->group_names.begin(); _iter1374 != this->group_names.end(); ++_iter1374) { - xfer += oprot->writeString((*_iter1375)); + xfer += oprot->writeString((*_iter1374)); } xfer += oprot->writeListEnd(); } @@ -29685,10 +29685,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 _iter1376; - for (_iter1376 = (*(this->group_names)).begin(); _iter1376 != (*(this->group_names)).end(); ++_iter1376) + std::vector ::const_iterator _iter1375; + for (_iter1375 = (*(this->group_names)).begin(); _iter1375 != (*(this->group_names)).end(); ++_iter1375) { - xfer += oprot->writeString((*_iter1376)); + xfer += oprot->writeString((*_iter1375)); } xfer += oprot->writeListEnd(); } @@ -29863,9 +29863,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1377; - xfer += iprot->readI32(ecast1377); - this->principal_type = (PrincipalType::type)ecast1377; + int32_t ecast1376; + xfer += iprot->readI32(ecast1376); + this->principal_type = (PrincipalType::type)ecast1376; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29970,14 +29970,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1378; - ::apache::thrift::protocol::TType _etype1381; - xfer += iprot->readListBegin(_etype1381, _size1378); - this->success.resize(_size1378); - uint32_t _i1382; - for (_i1382 = 0; _i1382 < _size1378; ++_i1382) + uint32_t _size1377; + ::apache::thrift::protocol::TType _etype1380; + xfer += iprot->readListBegin(_etype1380, _size1377); + this->success.resize(_size1377); + uint32_t _i1381; + for (_i1381 = 0; _i1381 < _size1377; ++_i1381) { - xfer += this->success[_i1382].read(iprot); + xfer += this->success[_i1381].read(iprot); } xfer += iprot->readListEnd(); } @@ -30016,10 +30016,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 _iter1383; - for (_iter1383 = this->success.begin(); _iter1383 != this->success.end(); ++_iter1383) + std::vector ::const_iterator _iter1382; + for (_iter1382 = this->success.begin(); _iter1382 != this->success.end(); ++_iter1382) { - xfer += (*_iter1383).write(oprot); + xfer += (*_iter1382).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30064,14 +30064,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1384; - ::apache::thrift::protocol::TType _etype1387; - xfer += iprot->readListBegin(_etype1387, _size1384); - (*(this->success)).resize(_size1384); - uint32_t _i1388; - for (_i1388 = 0; _i1388 < _size1384; ++_i1388) + uint32_t _size1383; + ::apache::thrift::protocol::TType _etype1386; + xfer += iprot->readListBegin(_etype1386, _size1383); + (*(this->success)).resize(_size1383); + uint32_t _i1387; + for (_i1387 = 0; _i1387 < _size1383; ++_i1387) { - xfer += (*(this->success))[_i1388].read(iprot); + xfer += (*(this->success))[_i1387].read(iprot); } xfer += iprot->readListEnd(); } @@ -30759,14 +30759,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 _size1389; - ::apache::thrift::protocol::TType _etype1392; - xfer += iprot->readListBegin(_etype1392, _size1389); - this->group_names.resize(_size1389); - uint32_t _i1393; - for (_i1393 = 0; _i1393 < _size1389; ++_i1393) + uint32_t _size1388; + ::apache::thrift::protocol::TType _etype1391; + xfer += iprot->readListBegin(_etype1391, _size1388); + this->group_names.resize(_size1388); + uint32_t _i1392; + for (_i1392 = 0; _i1392 < _size1388; ++_i1392) { - xfer += iprot->readString(this->group_names[_i1393]); + xfer += iprot->readString(this->group_names[_i1392]); } xfer += iprot->readListEnd(); } @@ -30799,10 +30799,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 _iter1394; - for (_iter1394 = this->group_names.begin(); _iter1394 != this->group_names.end(); ++_iter1394) + std::vector ::const_iterator _iter1393; + for (_iter1393 = this->group_names.begin(); _iter1393 != this->group_names.end(); ++_iter1393) { - xfer += oprot->writeString((*_iter1394)); + xfer += oprot->writeString((*_iter1393)); } xfer += oprot->writeListEnd(); } @@ -30830,10 +30830,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 _iter1395; - for (_iter1395 = (*(this->group_names)).begin(); _iter1395 != (*(this->group_names)).end(); ++_iter1395) + std::vector ::const_iterator _iter1394; + for (_iter1394 = (*(this->group_names)).begin(); _iter1394 != (*(this->group_names)).end(); ++_iter1394) { - xfer += oprot->writeString((*_iter1395)); + xfer += oprot->writeString((*_iter1394)); } xfer += oprot->writeListEnd(); } @@ -30874,14 +30874,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1396; - ::apache::thrift::protocol::TType _etype1399; - xfer += iprot->readListBegin(_etype1399, _size1396); - this->success.resize(_size1396); - uint32_t _i1400; - for (_i1400 = 0; _i1400 < _size1396; ++_i1400) + uint32_t _size1395; + ::apache::thrift::protocol::TType _etype1398; + xfer += iprot->readListBegin(_etype1398, _size1395); + this->success.resize(_size1395); + uint32_t _i1399; + for (_i1399 = 0; _i1399 < _size1395; ++_i1399) { - xfer += iprot->readString(this->success[_i1400]); + xfer += iprot->readString(this->success[_i1399]); } xfer += iprot->readListEnd(); } @@ -30920,10 +30920,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 _iter1401; - for (_iter1401 = this->success.begin(); _iter1401 != this->success.end(); ++_iter1401) + std::vector ::const_iterator _iter1400; + for (_iter1400 = this->success.begin(); _iter1400 != this->success.end(); ++_iter1400) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1400)); } xfer += oprot->writeListEnd(); } @@ -30968,14 +30968,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1402; - ::apache::thrift::protocol::TType _etype1405; - xfer += iprot->readListBegin(_etype1405, _size1402); - (*(this->success)).resize(_size1402); - uint32_t _i1406; - for (_i1406 = 0; _i1406 < _size1402; ++_i1406) + uint32_t _size1401; + ::apache::thrift::protocol::TType _etype1404; + xfer += iprot->readListBegin(_etype1404, _size1401); + (*(this->success)).resize(_size1401); + uint32_t _i1405; + for (_i1405 = 0; _i1405 < _size1401; ++_i1405) { - xfer += iprot->readString((*(this->success))[_i1406]); + xfer += iprot->readString((*(this->success))[_i1405]); } xfer += iprot->readListEnd(); } @@ -32286,14 +32286,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1407; - ::apache::thrift::protocol::TType _etype1410; - xfer += iprot->readListBegin(_etype1410, _size1407); - this->success.resize(_size1407); - uint32_t _i1411; - for (_i1411 = 0; _i1411 < _size1407; ++_i1411) + uint32_t _size1406; + ::apache::thrift::protocol::TType _etype1409; + xfer += iprot->readListBegin(_etype1409, _size1406); + this->success.resize(_size1406); + uint32_t _i1410; + for (_i1410 = 0; _i1410 < _size1406; ++_i1410) { - xfer += iprot->readString(this->success[_i1411]); + xfer += iprot->readString(this->success[_i1410]); } xfer += iprot->readListEnd(); } @@ -32324,10 +32324,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 _iter1412; - for (_iter1412 = this->success.begin(); _iter1412 != this->success.end(); ++_iter1412) + std::vector ::const_iterator _iter1411; + for (_iter1411 = this->success.begin(); _iter1411 != this->success.end(); ++_iter1411) { - xfer += oprot->writeString((*_iter1412)); + xfer += oprot->writeString((*_iter1411)); } xfer += oprot->writeListEnd(); } @@ -32368,14 +32368,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1413; - ::apache::thrift::protocol::TType _etype1416; - xfer += iprot->readListBegin(_etype1416, _size1413); - (*(this->success)).resize(_size1413); - uint32_t _i1417; - for (_i1417 = 0; _i1417 < _size1413; ++_i1417) + uint32_t _size1412; + ::apache::thrift::protocol::TType _etype1415; + xfer += iprot->readListBegin(_etype1415, _size1412); + (*(this->success)).resize(_size1412); + uint32_t _i1416; + for (_i1416 = 0; _i1416 < _size1412; ++_i1416) { - xfer += iprot->readString((*(this->success))[_i1417]); + xfer += iprot->readString((*(this->success))[_i1416]); } xfer += iprot->readListEnd(); } @@ -33101,14 +33101,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1418; - ::apache::thrift::protocol::TType _etype1421; - xfer += iprot->readListBegin(_etype1421, _size1418); - this->success.resize(_size1418); - uint32_t _i1422; - for (_i1422 = 0; _i1422 < _size1418; ++_i1422) + uint32_t _size1417; + ::apache::thrift::protocol::TType _etype1420; + xfer += iprot->readListBegin(_etype1420, _size1417); + this->success.resize(_size1417); + uint32_t _i1421; + for (_i1421 = 0; _i1421 < _size1417; ++_i1421) { - xfer += iprot->readString(this->success[_i1422]); + xfer += iprot->readString(this->success[_i1421]); } xfer += iprot->readListEnd(); } @@ -33139,10 +33139,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 _iter1423; - for (_iter1423 = this->success.begin(); _iter1423 != this->success.end(); ++_iter1423) + std::vector ::const_iterator _iter1422; + for (_iter1422 = this->success.begin(); _iter1422 != this->success.end(); ++_iter1422) { - xfer += oprot->writeString((*_iter1423)); + xfer += oprot->writeString((*_iter1422)); } xfer += oprot->writeListEnd(); } @@ -33183,14 +33183,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1424; - ::apache::thrift::protocol::TType _etype1427; - xfer += iprot->readListBegin(_etype1427, _size1424); - (*(this->success)).resize(_size1424); - uint32_t _i1428; - for (_i1428 = 0; _i1428 < _size1424; ++_i1428) + uint32_t _size1423; + ::apache::thrift::protocol::TType _etype1426; + xfer += iprot->readListBegin(_etype1426, _size1423); + (*(this->success)).resize(_size1423); + uint32_t _i1427; + for (_i1427 = 0; _i1427 < _size1423; ++_i1427) { - xfer += iprot->readString((*(this->success))[_i1428]); + xfer += iprot->readString((*(this->success))[_i1427]); } 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 b38e1cb..e3725a5 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -11981,7 +11981,7 @@ void GetOpenTxnsResponse::__set_txn_high_water_mark(const int64_t val) { this->txn_high_water_mark = val; } -void GetOpenTxnsResponse::__set_open_txns(const std::set & val) { +void GetOpenTxnsResponse::__set_open_txns(const std::vector & val) { this->open_txns = val; } @@ -11990,6 +11990,10 @@ void GetOpenTxnsResponse::__set_min_open_txn(const int64_t val) { __isset.min_open_txn = true; } +void GetOpenTxnsResponse::__set_abortedBits(const std::string& val) { + this->abortedBits = val; +} + uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -12004,6 +12008,7 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) bool isset_txn_high_water_mark = false; bool isset_open_txns = false; + bool isset_abortedBits = false; while (true) { @@ -12022,20 +12027,19 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) } break; case 2: - if (ftype == ::apache::thrift::protocol::T_SET) { + if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); uint32_t _size517; ::apache::thrift::protocol::TType _etype520; - xfer += iprot->readSetBegin(_etype520, _size517); + xfer += iprot->readListBegin(_etype520, _size517); + this->open_txns.resize(_size517); uint32_t _i521; for (_i521 = 0; _i521 < _size517; ++_i521) { - int64_t _elem522; - xfer += iprot->readI64(_elem522); - this->open_txns.insert(_elem522); + xfer += iprot->readI64(this->open_txns[_i521]); } - xfer += iprot->readSetEnd(); + xfer += iprot->readListEnd(); } isset_open_txns = true; } else { @@ -12050,6 +12054,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->abortedBits); + isset_abortedBits = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -12063,6 +12075,8 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) throw TProtocolException(TProtocolException::INVALID_DATA); if (!isset_open_txns) throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_abortedBits) + throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } @@ -12075,15 +12089,15 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeI64(this->txn_high_water_mark); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { - xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::set ::const_iterator _iter523; - for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); + std::vector ::const_iterator _iter522; + for (_iter522 = this->open_txns.begin(); _iter522 != this->open_txns.end(); ++_iter522) { - xfer += oprot->writeI64((*_iter523)); + xfer += oprot->writeI64((*_iter522)); } - xfer += oprot->writeSetEnd(); + xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); @@ -12092,6 +12106,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeI64(this->min_open_txn); xfer += oprot->writeFieldEnd(); } + xfer += oprot->writeFieldBegin("abortedBits", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->abortedBits); + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -12102,20 +12120,23 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.txn_high_water_mark, b.txn_high_water_mark); swap(a.open_txns, b.open_txns); swap(a.min_open_txn, b.min_open_txn); + swap(a.abortedBits, b.abortedBits); swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other524) { +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other523) { + txn_high_water_mark = other523.txn_high_water_mark; + open_txns = other523.open_txns; + min_open_txn = other523.min_open_txn; + abortedBits = other523.abortedBits; + __isset = other523.__isset; +} +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other524) { txn_high_water_mark = other524.txn_high_water_mark; open_txns = other524.open_txns; min_open_txn = other524.min_open_txn; + abortedBits = other524.abortedBits; __isset = other524.__isset; -} -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other525) { - txn_high_water_mark = other525.txn_high_water_mark; - open_txns = other525.open_txns; - min_open_txn = other525.min_open_txn; - __isset = other525.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -12124,6 +12145,7 @@ void GetOpenTxnsResponse::printTo(std::ostream& out) const { out << "txn_high_water_mark=" << to_string(txn_high_water_mark); out << ", " << "open_txns=" << to_string(open_txns); out << ", " << "min_open_txn="; (__isset.min_open_txn ? (out << to_string(min_open_txn)) : (out << "")); + out << ", " << "abortedBits=" << to_string(abortedBits); out << ")"; } @@ -12259,19 +12281,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other526) { +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other525) { + num_txns = other525.num_txns; + user = other525.user; + hostname = other525.hostname; + agentInfo = other525.agentInfo; + __isset = other525.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other526) { num_txns = other526.num_txns; user = other526.user; hostname = other526.hostname; agentInfo = other526.agentInfo; __isset = other526.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other527) { - num_txns = other527.num_txns; - user = other527.user; - hostname = other527.hostname; - agentInfo = other527.agentInfo; - __isset = other527.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -12319,14 +12341,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size528; - ::apache::thrift::protocol::TType _etype531; - xfer += iprot->readListBegin(_etype531, _size528); - this->txn_ids.resize(_size528); - uint32_t _i532; - for (_i532 = 0; _i532 < _size528; ++_i532) + uint32_t _size527; + ::apache::thrift::protocol::TType _etype530; + xfer += iprot->readListBegin(_etype530, _size527); + this->txn_ids.resize(_size527); + uint32_t _i531; + for (_i531 = 0; _i531 < _size527; ++_i531) { - xfer += iprot->readI64(this->txn_ids[_i532]); + xfer += iprot->readI64(this->txn_ids[_i531]); } xfer += iprot->readListEnd(); } @@ -12357,10 +12379,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter533; - for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533) + std::vector ::const_iterator _iter532; + for (_iter532 = this->txn_ids.begin(); _iter532 != this->txn_ids.end(); ++_iter532) { - xfer += oprot->writeI64((*_iter533)); + xfer += oprot->writeI64((*_iter532)); } xfer += oprot->writeListEnd(); } @@ -12376,11 +12398,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) { - txn_ids = other534.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other533) { + txn_ids = other533.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) { - txn_ids = other535.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other534) { + txn_ids = other534.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -12462,11 +12484,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) { - txnid = other536.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other535) { + txnid = other535.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) { - txnid = other537.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other536) { + txnid = other536.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12511,14 +12533,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size538; - ::apache::thrift::protocol::TType _etype541; - xfer += iprot->readListBegin(_etype541, _size538); - this->txn_ids.resize(_size538); - uint32_t _i542; - for (_i542 = 0; _i542 < _size538; ++_i542) + uint32_t _size537; + ::apache::thrift::protocol::TType _etype540; + xfer += iprot->readListBegin(_etype540, _size537); + this->txn_ids.resize(_size537); + uint32_t _i541; + for (_i541 = 0; _i541 < _size537; ++_i541) { - xfer += iprot->readI64(this->txn_ids[_i542]); + xfer += iprot->readI64(this->txn_ids[_i541]); } xfer += iprot->readListEnd(); } @@ -12549,10 +12571,10 @@ uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter543; - for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543) + std::vector ::const_iterator _iter542; + for (_iter542 = this->txn_ids.begin(); _iter542 != this->txn_ids.end(); ++_iter542) { - xfer += oprot->writeI64((*_iter543)); + xfer += oprot->writeI64((*_iter542)); } xfer += oprot->writeListEnd(); } @@ -12568,11 +12590,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) { - txn_ids = other544.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other543) { + txn_ids = other543.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) { - txn_ids = other545.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other544) { + txn_ids = other544.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -12654,11 +12676,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) { - txnid = other546.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other545) { + txnid = other545.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) { - txnid = other547.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other546) { + txnid = other546.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12736,9 +12758,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast548; - xfer += iprot->readI32(ecast548); - this->type = (LockType::type)ecast548; + int32_t ecast547; + xfer += iprot->readI32(ecast547); + this->type = (LockType::type)ecast547; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12746,9 +12768,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast549; - xfer += iprot->readI32(ecast549); - this->level = (LockLevel::type)ecast549; + int32_t ecast548; + xfer += iprot->readI32(ecast548); + this->level = (LockLevel::type)ecast548; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12780,9 +12802,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast550; - xfer += iprot->readI32(ecast550); - this->operationType = (DataOperationType::type)ecast550; + int32_t ecast549; + xfer += iprot->readI32(ecast549); + this->operationType = (DataOperationType::type)ecast549; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -12882,7 +12904,18 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other551) { +LockComponent::LockComponent(const LockComponent& other550) { + type = other550.type; + level = other550.level; + dbname = other550.dbname; + tablename = other550.tablename; + partitionname = other550.partitionname; + operationType = other550.operationType; + isAcid = other550.isAcid; + isDynamicPartitionWrite = other550.isDynamicPartitionWrite; + __isset = other550.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other551) { type = other551.type; level = other551.level; dbname = other551.dbname; @@ -12892,17 +12925,6 @@ LockComponent::LockComponent(const LockComponent& other551) { isAcid = other551.isAcid; isDynamicPartitionWrite = other551.isDynamicPartitionWrite; __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; - isDynamicPartitionWrite = other552.isDynamicPartitionWrite; - __isset = other552.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12974,14 +12996,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - 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) + 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) { - xfer += this->component[_i557].read(iprot); + xfer += this->component[_i556].read(iprot); } xfer += iprot->readListEnd(); } @@ -13048,10 +13070,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 _iter558; - for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558) + std::vector ::const_iterator _iter557; + for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557) { - xfer += (*_iter558).write(oprot); + xfer += (*_iter557).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13090,21 +13112,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other559) { +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) { 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 { @@ -13164,9 +13186,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast561; - xfer += iprot->readI32(ecast561); - this->state = (LockState::type)ecast561; + int32_t ecast560; + xfer += iprot->readI32(ecast560); + this->state = (LockState::type)ecast560; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13212,13 +13234,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other562) { +LockResponse::LockResponse(const LockResponse& other561) { + lockid = other561.lockid; + state = other561.state; +} +LockResponse& LockResponse::operator=(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 { @@ -13340,17 +13362,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other564) { +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) { 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 { @@ -13434,11 +13456,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other566) { - lockid = other566.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other565) { + lockid = other565.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) { - lockid = other567.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) { + lockid = other566.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -13577,19 +13599,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other568) { +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) { 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 { @@ -13742,9 +13764,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast570; - xfer += iprot->readI32(ecast570); - this->state = (LockState::type)ecast570; + int32_t ecast569; + xfer += iprot->readI32(ecast569); + this->state = (LockState::type)ecast569; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13752,9 +13774,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast571; - xfer += iprot->readI32(ecast571); - this->type = (LockType::type)ecast571; + int32_t ecast570; + xfer += iprot->readI32(ecast570); + this->type = (LockType::type)ecast570; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13970,7 +13992,26 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) { +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) { lockid = other572.lockid; dbname = other572.dbname; tablename = other572.tablename; @@ -13988,25 +14029,6 @@ ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElemen 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 { @@ -14065,14 +14087,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - 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) + 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) { - xfer += this->locks[_i578].read(iprot); + xfer += this->locks[_i577].read(iprot); } xfer += iprot->readListEnd(); } @@ -14101,10 +14123,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 _iter579; - for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579) + std::vector ::const_iterator _iter578; + for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578) { - xfer += (*_iter579).write(oprot); + xfer += (*_iter578).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14121,13 +14143,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other580) { +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) { + locks = other579.locks; + __isset = other579.__isset; +} +ShowLocksResponse& ShowLocksResponse::operator=(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 { @@ -14228,15 +14250,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other582) { +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) { + lockid = other581.lockid; + txnid = other581.txnid; + __isset = other581.__isset; +} +HeartbeatRequest& HeartbeatRequest::operator=(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 { @@ -14339,13 +14361,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other584) { +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) { + min = other583.min; + max = other583.max; +} +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(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 { @@ -14396,15 +14418,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size586; - ::apache::thrift::protocol::TType _etype589; - xfer += iprot->readSetBegin(_etype589, _size586); - uint32_t _i590; - for (_i590 = 0; _i590 < _size586; ++_i590) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readSetBegin(_etype588, _size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - int64_t _elem591; - xfer += iprot->readI64(_elem591); - this->aborted.insert(_elem591); + int64_t _elem590; + xfer += iprot->readI64(_elem590); + this->aborted.insert(_elem590); } xfer += iprot->readSetEnd(); } @@ -14417,15 +14439,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readSetBegin(_etype595, _size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + uint32_t _size591; + ::apache::thrift::protocol::TType _etype594; + xfer += iprot->readSetBegin(_etype594, _size591); + uint32_t _i595; + for (_i595 = 0; _i595 < _size591; ++_i595) { - int64_t _elem597; - xfer += iprot->readI64(_elem597); - this->nosuch.insert(_elem597); + int64_t _elem596; + xfer += iprot->readI64(_elem596); + this->nosuch.insert(_elem596); } xfer += iprot->readSetEnd(); } @@ -14458,10 +14480,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 _iter598; - for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598) + std::set ::const_iterator _iter597; + for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597) { - xfer += oprot->writeI64((*_iter598)); + xfer += oprot->writeI64((*_iter597)); } xfer += oprot->writeSetEnd(); } @@ -14470,10 +14492,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 _iter599; - for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599) + std::set ::const_iterator _iter598; + for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598) { - xfer += oprot->writeI64((*_iter599)); + xfer += oprot->writeI64((*_iter598)); } xfer += oprot->writeSetEnd(); } @@ -14490,13 +14512,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other600) { +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) { + aborted = other599.aborted; + nosuch = other599.nosuch; +} +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(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 { @@ -14589,9 +14611,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast602; - xfer += iprot->readI32(ecast602); - this->type = (CompactionType::type)ecast602; + int32_t ecast601; + xfer += iprot->readI32(ecast601); + this->type = (CompactionType::type)ecast601; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14609,17 +14631,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _ktype604; - ::apache::thrift::protocol::TType _vtype605; - xfer += iprot->readMapBegin(_ktype604, _vtype605, _size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size602; + ::apache::thrift::protocol::TType _ktype603; + ::apache::thrift::protocol::TType _vtype604; + xfer += iprot->readMapBegin(_ktype603, _vtype604, _size602); + uint32_t _i606; + for (_i606 = 0; _i606 < _size602; ++_i606) { - std::string _key608; - xfer += iprot->readString(_key608); - std::string& _val609 = this->properties[_key608]; - xfer += iprot->readString(_val609); + std::string _key607; + xfer += iprot->readString(_key607); + std::string& _val608 = this->properties[_key607]; + xfer += iprot->readString(_val608); } xfer += iprot->readMapEnd(); } @@ -14677,11 +14699,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter610; - for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610) + std::map ::const_iterator _iter609; + for (_iter609 = this->properties.begin(); _iter609 != this->properties.end(); ++_iter609) { - xfer += oprot->writeString(_iter610->first); - xfer += oprot->writeString(_iter610->second); + xfer += oprot->writeString(_iter609->first); + xfer += oprot->writeString(_iter609->second); } xfer += oprot->writeMapEnd(); } @@ -14703,7 +14725,16 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other611) { +CompactionRequest::CompactionRequest(const CompactionRequest& other610) { + dbname = other610.dbname; + tablename = other610.tablename; + partitionname = other610.partitionname; + type = other610.type; + runas = other610.runas; + properties = other610.properties; + __isset = other610.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other611) { dbname = other611.dbname; tablename = other611.tablename; partitionname = other611.partitionname; @@ -14711,15 +14742,6 @@ CompactionRequest::CompactionRequest(const CompactionRequest& other611) { runas = other611.runas; properties = other611.properties; __isset = other611.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other612) { - dbname = other612.dbname; - tablename = other612.tablename; - partitionname = other612.partitionname; - type = other612.type; - runas = other612.runas; - properties = other612.properties; - __isset = other612.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14846,15 +14868,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other613) { +CompactionResponse::CompactionResponse(const CompactionResponse& other612) { + id = other612.id; + state = other612.state; + accepted = other612.accepted; +} +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other613) { id = other613.id; state = other613.state; accepted = other613.accepted; -} -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other614) { - id = other614.id; - state = other614.state; - accepted = other614.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -14915,11 +14937,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) { - (void) other615; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other614) { + (void) other614; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) { - (void) other616; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other615) { + (void) other615; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -15045,9 +15067,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast617; - xfer += iprot->readI32(ecast617); - this->type = (CompactionType::type)ecast617; + int32_t ecast616; + xfer += iprot->readI32(ecast616); + this->type = (CompactionType::type)ecast616; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15234,7 +15256,23 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) { +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other617) { + dbname = other617.dbname; + tablename = other617.tablename; + partitionname = other617.partitionname; + type = other617.type; + state = other617.state; + workerid = other617.workerid; + start = other617.start; + runAs = other617.runAs; + hightestTxnId = other617.hightestTxnId; + metaInfo = other617.metaInfo; + endTime = other617.endTime; + hadoopJobId = other617.hadoopJobId; + id = other617.id; + __isset = other617.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other618) { dbname = other618.dbname; tablename = other618.tablename; partitionname = other618.partitionname; @@ -15249,22 +15287,6 @@ ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponse hadoopJobId = other618.hadoopJobId; id = other618.id; __isset = other618.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other619) { - dbname = other619.dbname; - tablename = other619.tablename; - partitionname = other619.partitionname; - type = other619.type; - state = other619.state; - workerid = other619.workerid; - start = other619.start; - runAs = other619.runAs; - hightestTxnId = other619.hightestTxnId; - metaInfo = other619.metaInfo; - endTime = other619.endTime; - hadoopJobId = other619.hadoopJobId; - id = other619.id; - __isset = other619.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -15321,14 +15343,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size620; - ::apache::thrift::protocol::TType _etype623; - xfer += iprot->readListBegin(_etype623, _size620); - this->compacts.resize(_size620); - uint32_t _i624; - for (_i624 = 0; _i624 < _size620; ++_i624) + uint32_t _size619; + ::apache::thrift::protocol::TType _etype622; + xfer += iprot->readListBegin(_etype622, _size619); + this->compacts.resize(_size619); + uint32_t _i623; + for (_i623 = 0; _i623 < _size619; ++_i623) { - xfer += this->compacts[_i624].read(iprot); + xfer += this->compacts[_i623].read(iprot); } xfer += iprot->readListEnd(); } @@ -15359,10 +15381,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 _iter625; - for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625) + std::vector ::const_iterator _iter624; + for (_iter624 = this->compacts.begin(); _iter624 != this->compacts.end(); ++_iter624) { - xfer += (*_iter625).write(oprot); + xfer += (*_iter624).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15378,11 +15400,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) { - compacts = other626.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other625) { + compacts = other625.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) { - compacts = other627.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other626) { + compacts = other626.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15471,14 +15493,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size628; - ::apache::thrift::protocol::TType _etype631; - xfer += iprot->readListBegin(_etype631, _size628); - this->partitionnames.resize(_size628); - uint32_t _i632; - for (_i632 = 0; _i632 < _size628; ++_i632) + uint32_t _size627; + ::apache::thrift::protocol::TType _etype630; + xfer += iprot->readListBegin(_etype630, _size627); + this->partitionnames.resize(_size627); + uint32_t _i631; + for (_i631 = 0; _i631 < _size627; ++_i631) { - xfer += iprot->readString(this->partitionnames[_i632]); + xfer += iprot->readString(this->partitionnames[_i631]); } xfer += iprot->readListEnd(); } @@ -15489,9 +15511,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast633; - xfer += iprot->readI32(ecast633); - this->operationType = (DataOperationType::type)ecast633; + int32_t ecast632; + xfer += iprot->readI32(ecast632); + this->operationType = (DataOperationType::type)ecast632; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15537,10 +15559,10 @@ 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 _iter634; - for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634) + std::vector ::const_iterator _iter633; + for (_iter633 = this->partitionnames.begin(); _iter633 != this->partitionnames.end(); ++_iter633) { - xfer += oprot->writeString((*_iter634)); + xfer += oprot->writeString((*_iter633)); } xfer += oprot->writeListEnd(); } @@ -15566,21 +15588,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other635) { +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other634) { + txnid = other634.txnid; + dbname = other634.dbname; + tablename = other634.tablename; + partitionnames = other634.partitionnames; + operationType = other634.operationType; + __isset = other634.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other635) { txnid = other635.txnid; dbname = other635.dbname; tablename = other635.tablename; partitionnames = other635.partitionnames; operationType = other635.operationType; __isset = other635.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other636) { - txnid = other636.txnid; - dbname = other636.dbname; - tablename = other636.tablename; - partitionnames = other636.partitionnames; - operationType = other636.operationType; - __isset = other636.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -15686,15 +15708,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other637) { +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other636) { + lastEvent = other636.lastEvent; + maxEvents = other636.maxEvents; + __isset = other636.__isset; +} +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other637) { lastEvent = other637.lastEvent; maxEvents = other637.maxEvents; __isset = other637.__isset; -} -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other638) { - lastEvent = other638.lastEvent; - maxEvents = other638.maxEvents; - __isset = other638.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -15895,7 +15917,17 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other639) { +NotificationEvent::NotificationEvent(const NotificationEvent& other638) { + eventId = other638.eventId; + eventTime = other638.eventTime; + eventType = other638.eventType; + dbName = other638.dbName; + tableName = other638.tableName; + message = other638.message; + messageFormat = other638.messageFormat; + __isset = other638.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other639) { eventId = other639.eventId; eventTime = other639.eventTime; eventType = other639.eventType; @@ -15904,16 +15936,6 @@ NotificationEvent::NotificationEvent(const NotificationEvent& other639) { message = other639.message; messageFormat = other639.messageFormat; __isset = other639.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other640) { - eventId = other640.eventId; - eventTime = other640.eventTime; - eventType = other640.eventType; - dbName = other640.dbName; - tableName = other640.tableName; - message = other640.message; - messageFormat = other640.messageFormat; - __isset = other640.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15964,14 +15986,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - this->events.resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size640; + ::apache::thrift::protocol::TType _etype643; + xfer += iprot->readListBegin(_etype643, _size640); + this->events.resize(_size640); + uint32_t _i644; + for (_i644 = 0; _i644 < _size640; ++_i644) { - xfer += this->events[_i645].read(iprot); + xfer += this->events[_i644].read(iprot); } xfer += iprot->readListEnd(); } @@ -16002,10 +16024,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 _iter646; - for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646) + std::vector ::const_iterator _iter645; + for (_iter645 = this->events.begin(); _iter645 != this->events.end(); ++_iter645) { - xfer += (*_iter646).write(oprot); + xfer += (*_iter645).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16021,11 +16043,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) { - events = other647.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other646) { + events = other646.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) { - events = other648.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other647) { + events = other647.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -16107,11 +16129,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) { - eventId = other649.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other648) { + eventId = other648.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) { - eventId = other650.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other649) { + eventId = other649.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -16174,14 +16196,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size651; - ::apache::thrift::protocol::TType _etype654; - xfer += iprot->readListBegin(_etype654, _size651); - this->filesAdded.resize(_size651); - uint32_t _i655; - for (_i655 = 0; _i655 < _size651; ++_i655) + uint32_t _size650; + ::apache::thrift::protocol::TType _etype653; + xfer += iprot->readListBegin(_etype653, _size650); + this->filesAdded.resize(_size650); + uint32_t _i654; + for (_i654 = 0; _i654 < _size650; ++_i654) { - xfer += iprot->readString(this->filesAdded[_i655]); + xfer += iprot->readString(this->filesAdded[_i654]); } xfer += iprot->readListEnd(); } @@ -16194,14 +16216,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size656; - ::apache::thrift::protocol::TType _etype659; - xfer += iprot->readListBegin(_etype659, _size656); - this->filesAddedChecksum.resize(_size656); - uint32_t _i660; - for (_i660 = 0; _i660 < _size656; ++_i660) + uint32_t _size655; + ::apache::thrift::protocol::TType _etype658; + xfer += iprot->readListBegin(_etype658, _size655); + this->filesAddedChecksum.resize(_size655); + uint32_t _i659; + for (_i659 = 0; _i659 < _size655; ++_i659) { - xfer += iprot->readString(this->filesAddedChecksum[_i660]); + xfer += iprot->readString(this->filesAddedChecksum[_i659]); } xfer += iprot->readListEnd(); } @@ -16237,10 +16259,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter661; - for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661) + std::vector ::const_iterator _iter660; + for (_iter660 = this->filesAdded.begin(); _iter660 != this->filesAdded.end(); ++_iter660) { - xfer += oprot->writeString((*_iter661)); + xfer += oprot->writeString((*_iter660)); } xfer += oprot->writeListEnd(); } @@ -16250,10 +16272,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAddedChecksum.size())); - std::vector ::const_iterator _iter662; - for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662) + std::vector ::const_iterator _iter661; + for (_iter661 = this->filesAddedChecksum.begin(); _iter661 != this->filesAddedChecksum.end(); ++_iter661) { - xfer += oprot->writeString((*_iter662)); + xfer += oprot->writeString((*_iter661)); } xfer += oprot->writeListEnd(); } @@ -16272,17 +16294,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other663) { +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other662) { + replace = other662.replace; + filesAdded = other662.filesAdded; + filesAddedChecksum = other662.filesAddedChecksum; + __isset = other662.__isset; +} +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other663) { replace = other663.replace; filesAdded = other663.filesAdded; filesAddedChecksum = other663.filesAddedChecksum; __isset = other663.__isset; -} -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other664) { - replace = other664.replace; - filesAdded = other664.filesAdded; - filesAddedChecksum = other664.filesAddedChecksum; - __isset = other664.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -16364,13 +16386,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other665) { +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other664) { + insertData = other664.insertData; + __isset = other664.__isset; +} +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other665) { insertData = other665.insertData; __isset = other665.__isset; -} -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other666) { - insertData = other666.insertData; - __isset = other666.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -16467,14 +16489,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size667; - ::apache::thrift::protocol::TType _etype670; - xfer += iprot->readListBegin(_etype670, _size667); - this->partitionVals.resize(_size667); - uint32_t _i671; - for (_i671 = 0; _i671 < _size667; ++_i671) + uint32_t _size666; + ::apache::thrift::protocol::TType _etype669; + xfer += iprot->readListBegin(_etype669, _size666); + this->partitionVals.resize(_size666); + uint32_t _i670; + for (_i670 = 0; _i670 < _size666; ++_i670) { - xfer += iprot->readString(this->partitionVals[_i671]); + xfer += iprot->readString(this->partitionVals[_i670]); } xfer += iprot->readListEnd(); } @@ -16526,10 +16548,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 _iter672; - for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672) + std::vector ::const_iterator _iter671; + for (_iter671 = this->partitionVals.begin(); _iter671 != this->partitionVals.end(); ++_iter671) { - xfer += oprot->writeString((*_iter672)); + xfer += oprot->writeString((*_iter671)); } xfer += oprot->writeListEnd(); } @@ -16550,21 +16572,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other673) { +FireEventRequest::FireEventRequest(const FireEventRequest& other672) { + successful = other672.successful; + data = other672.data; + dbName = other672.dbName; + tableName = other672.tableName; + partitionVals = other672.partitionVals; + __isset = other672.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other673) { successful = other673.successful; data = other673.data; dbName = other673.dbName; tableName = other673.tableName; partitionVals = other673.partitionVals; __isset = other673.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other674) { - successful = other674.successful; - data = other674.data; - dbName = other674.dbName; - tableName = other674.tableName; - partitionVals = other674.partitionVals; - __isset = other674.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16627,11 +16649,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other675) { - (void) other675; +FireEventResponse::FireEventResponse(const FireEventResponse& other674) { + (void) other674; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other676) { - (void) other676; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other675) { + (void) other675; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16731,15 +16753,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other677) { +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other676) { + metadata = other676.metadata; + includeBitset = other676.includeBitset; + __isset = other676.__isset; +} +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other677) { metadata = other677.metadata; includeBitset = other677.includeBitset; __isset = other677.__isset; -} -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other678) { - metadata = other678.metadata; - includeBitset = other678.includeBitset; - __isset = other678.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16790,17 +16812,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size679; - ::apache::thrift::protocol::TType _ktype680; - ::apache::thrift::protocol::TType _vtype681; - xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); - uint32_t _i683; - for (_i683 = 0; _i683 < _size679; ++_i683) + uint32_t _size678; + ::apache::thrift::protocol::TType _ktype679; + ::apache::thrift::protocol::TType _vtype680; + xfer += iprot->readMapBegin(_ktype679, _vtype680, _size678); + uint32_t _i682; + for (_i682 = 0; _i682 < _size678; ++_i682) { - int64_t _key684; - xfer += iprot->readI64(_key684); - MetadataPpdResult& _val685 = this->metadata[_key684]; - xfer += _val685.read(iprot); + int64_t _key683; + xfer += iprot->readI64(_key683); + MetadataPpdResult& _val684 = this->metadata[_key683]; + xfer += _val684.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16841,11 +16863,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 _iter686; - for (_iter686 = this->metadata.begin(); _iter686 != this->metadata.end(); ++_iter686) + std::map ::const_iterator _iter685; + for (_iter685 = this->metadata.begin(); _iter685 != this->metadata.end(); ++_iter685) { - xfer += oprot->writeI64(_iter686->first); - xfer += _iter686->second.write(oprot); + xfer += oprot->writeI64(_iter685->first); + xfer += _iter685->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16866,13 +16888,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other687) { +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other686) { + metadata = other686.metadata; + isSupported = other686.isSupported; +} +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other687) { metadata = other687.metadata; isSupported = other687.isSupported; -} -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other688) { - metadata = other688.metadata; - isSupported = other688.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16933,14 +16955,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size689; - ::apache::thrift::protocol::TType _etype692; - xfer += iprot->readListBegin(_etype692, _size689); - this->fileIds.resize(_size689); - uint32_t _i693; - for (_i693 = 0; _i693 < _size689; ++_i693) + uint32_t _size688; + ::apache::thrift::protocol::TType _etype691; + xfer += iprot->readListBegin(_etype691, _size688); + this->fileIds.resize(_size688); + uint32_t _i692; + for (_i692 = 0; _i692 < _size688; ++_i692) { - xfer += iprot->readI64(this->fileIds[_i693]); + xfer += iprot->readI64(this->fileIds[_i692]); } xfer += iprot->readListEnd(); } @@ -16967,9 +16989,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast694; - xfer += iprot->readI32(ecast694); - this->type = (FileMetadataExprType::type)ecast694; + int32_t ecast693; + xfer += iprot->readI32(ecast693); + this->type = (FileMetadataExprType::type)ecast693; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16999,10 +17021,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 _iter695; - for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695) + std::vector ::const_iterator _iter694; + for (_iter694 = this->fileIds.begin(); _iter694 != this->fileIds.end(); ++_iter694) { - xfer += oprot->writeI64((*_iter695)); + xfer += oprot->writeI64((*_iter694)); } xfer += oprot->writeListEnd(); } @@ -17036,19 +17058,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other696) { +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other695) { + fileIds = other695.fileIds; + expr = other695.expr; + doGetFooters = other695.doGetFooters; + type = other695.type; + __isset = other695.__isset; +} +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other696) { fileIds = other696.fileIds; expr = other696.expr; doGetFooters = other696.doGetFooters; type = other696.type; __isset = other696.__isset; -} -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other697) { - fileIds = other697.fileIds; - expr = other697.expr; - doGetFooters = other697.doGetFooters; - type = other697.type; - __isset = other697.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -17101,17 +17123,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size698; - ::apache::thrift::protocol::TType _ktype699; - ::apache::thrift::protocol::TType _vtype700; - xfer += iprot->readMapBegin(_ktype699, _vtype700, _size698); - uint32_t _i702; - for (_i702 = 0; _i702 < _size698; ++_i702) + uint32_t _size697; + ::apache::thrift::protocol::TType _ktype698; + ::apache::thrift::protocol::TType _vtype699; + xfer += iprot->readMapBegin(_ktype698, _vtype699, _size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - int64_t _key703; - xfer += iprot->readI64(_key703); - std::string& _val704 = this->metadata[_key703]; - xfer += iprot->readBinary(_val704); + int64_t _key702; + xfer += iprot->readI64(_key702); + std::string& _val703 = this->metadata[_key702]; + xfer += iprot->readBinary(_val703); } xfer += iprot->readMapEnd(); } @@ -17152,11 +17174,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 _iter705; - for (_iter705 = this->metadata.begin(); _iter705 != this->metadata.end(); ++_iter705) + std::map ::const_iterator _iter704; + for (_iter704 = this->metadata.begin(); _iter704 != this->metadata.end(); ++_iter704) { - xfer += oprot->writeI64(_iter705->first); - xfer += oprot->writeBinary(_iter705->second); + xfer += oprot->writeI64(_iter704->first); + xfer += oprot->writeBinary(_iter704->second); } xfer += oprot->writeMapEnd(); } @@ -17177,13 +17199,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other706) { +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other705) { + metadata = other705.metadata; + isSupported = other705.isSupported; +} +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other706) { metadata = other706.metadata; isSupported = other706.isSupported; -} -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other707) { - metadata = other707.metadata; - isSupported = other707.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -17229,14 +17251,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size708; - ::apache::thrift::protocol::TType _etype711; - xfer += iprot->readListBegin(_etype711, _size708); - this->fileIds.resize(_size708); - uint32_t _i712; - for (_i712 = 0; _i712 < _size708; ++_i712) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readListBegin(_etype710, _size707); + this->fileIds.resize(_size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - xfer += iprot->readI64(this->fileIds[_i712]); + xfer += iprot->readI64(this->fileIds[_i711]); } xfer += iprot->readListEnd(); } @@ -17267,10 +17289,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 _iter713; - for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713) + std::vector ::const_iterator _iter712; + for (_iter712 = this->fileIds.begin(); _iter712 != this->fileIds.end(); ++_iter712) { - xfer += oprot->writeI64((*_iter713)); + xfer += oprot->writeI64((*_iter712)); } xfer += oprot->writeListEnd(); } @@ -17286,11 +17308,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other714) { - fileIds = other714.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other713) { + fileIds = other713.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other715) { - fileIds = other715.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other714) { + fileIds = other714.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -17349,11 +17371,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other716) { - (void) other716; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other715) { + (void) other715; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other717) { - (void) other717; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other716) { + (void) other716; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -17407,14 +17429,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _etype721; - xfer += iprot->readListBegin(_etype721, _size718); - this->fileIds.resize(_size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + 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) { - xfer += iprot->readI64(this->fileIds[_i722]); + xfer += iprot->readI64(this->fileIds[_i721]); } xfer += iprot->readListEnd(); } @@ -17427,14 +17449,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size723; - ::apache::thrift::protocol::TType _etype726; - xfer += iprot->readListBegin(_etype726, _size723); - this->metadata.resize(_size723); - uint32_t _i727; - for (_i727 = 0; _i727 < _size723; ++_i727) + uint32_t _size722; + ::apache::thrift::protocol::TType _etype725; + xfer += iprot->readListBegin(_etype725, _size722); + this->metadata.resize(_size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - xfer += iprot->readBinary(this->metadata[_i727]); + xfer += iprot->readBinary(this->metadata[_i726]); } xfer += iprot->readListEnd(); } @@ -17445,9 +17467,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast728; - xfer += iprot->readI32(ecast728); - this->type = (FileMetadataExprType::type)ecast728; + int32_t ecast727; + xfer += iprot->readI32(ecast727); + this->type = (FileMetadataExprType::type)ecast727; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17477,10 +17499,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 _iter729; - for (_iter729 = this->fileIds.begin(); _iter729 != this->fileIds.end(); ++_iter729) + std::vector ::const_iterator _iter728; + for (_iter728 = this->fileIds.begin(); _iter728 != this->fileIds.end(); ++_iter728) { - xfer += oprot->writeI64((*_iter729)); + xfer += oprot->writeI64((*_iter728)); } xfer += oprot->writeListEnd(); } @@ -17489,10 +17511,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 _iter730; - for (_iter730 = this->metadata.begin(); _iter730 != this->metadata.end(); ++_iter730) + std::vector ::const_iterator _iter729; + for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729) { - xfer += oprot->writeBinary((*_iter730)); + xfer += oprot->writeBinary((*_iter729)); } xfer += oprot->writeListEnd(); } @@ -17516,17 +17538,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other731) { +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other730) { + fileIds = other730.fileIds; + metadata = other730.metadata; + type = other730.type; + __isset = other730.__isset; +} +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other731) { fileIds = other731.fileIds; metadata = other731.metadata; type = other731.type; __isset = other731.__isset; -} -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other732) { - fileIds = other732.fileIds; - metadata = other732.metadata; - type = other732.type; - __isset = other732.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17587,11 +17609,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other733) { - (void) other733; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other732) { + (void) other732; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other734) { - (void) other734; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other733) { + (void) other733; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17635,14 +17657,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size735; - ::apache::thrift::protocol::TType _etype738; - xfer += iprot->readListBegin(_etype738, _size735); - this->fileIds.resize(_size735); - uint32_t _i739; - for (_i739 = 0; _i739 < _size735; ++_i739) + uint32_t _size734; + ::apache::thrift::protocol::TType _etype737; + xfer += iprot->readListBegin(_etype737, _size734); + this->fileIds.resize(_size734); + uint32_t _i738; + for (_i738 = 0; _i738 < _size734; ++_i738) { - xfer += iprot->readI64(this->fileIds[_i739]); + xfer += iprot->readI64(this->fileIds[_i738]); } xfer += iprot->readListEnd(); } @@ -17673,10 +17695,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 _iter740; - for (_iter740 = this->fileIds.begin(); _iter740 != this->fileIds.end(); ++_iter740) + std::vector ::const_iterator _iter739; + for (_iter739 = this->fileIds.begin(); _iter739 != this->fileIds.end(); ++_iter739) { - xfer += oprot->writeI64((*_iter740)); + xfer += oprot->writeI64((*_iter739)); } xfer += oprot->writeListEnd(); } @@ -17692,11 +17714,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other741) { - fileIds = other741.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other740) { + fileIds = other740.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other742) { - fileIds = other742.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other741) { + fileIds = other741.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17778,11 +17800,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other743) { - isSupported = other743.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other742) { + isSupported = other742.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other744) { - isSupported = other744.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other743) { + isSupported = other743.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17923,19 +17945,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other745) { +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other744) { + dbName = other744.dbName; + tblName = other744.tblName; + partName = other744.partName; + isAllParts = other744.isAllParts; + __isset = other744.__isset; +} +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other745) { dbName = other745.dbName; tblName = other745.tblName; partName = other745.partName; isAllParts = other745.isAllParts; __isset = other745.__isset; -} -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other746) { - dbName = other746.dbName; - tblName = other746.tblName; - partName = other746.partName; - isAllParts = other746.isAllParts; - __isset = other746.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17983,14 +18005,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - this->functions.resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size746; + ::apache::thrift::protocol::TType _etype749; + xfer += iprot->readListBegin(_etype749, _size746); + this->functions.resize(_size746); + uint32_t _i750; + for (_i750 = 0; _i750 < _size746; ++_i750) { - xfer += this->functions[_i751].read(iprot); + xfer += this->functions[_i750].read(iprot); } xfer += iprot->readListEnd(); } @@ -18020,10 +18042,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 _iter752; - for (_iter752 = this->functions.begin(); _iter752 != this->functions.end(); ++_iter752) + std::vector ::const_iterator _iter751; + for (_iter751 = this->functions.begin(); _iter751 != this->functions.end(); ++_iter751) { - xfer += (*_iter752).write(oprot); + xfer += (*_iter751).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18040,13 +18062,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other753) { +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other752) { + functions = other752.functions; + __isset = other752.__isset; +} +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other753) { functions = other753.functions; __isset = other753.__isset; -} -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other754) { - functions = other754.functions; - __isset = other754.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -18091,16 +18113,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - this->values.resize(_size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + uint32_t _size754; + ::apache::thrift::protocol::TType _etype757; + xfer += iprot->readListBegin(_etype757, _size754); + this->values.resize(_size754); + uint32_t _i758; + for (_i758 = 0; _i758 < _size754; ++_i758) { - int32_t ecast760; - xfer += iprot->readI32(ecast760); - this->values[_i759] = (ClientCapability::type)ecast760; + int32_t ecast759; + xfer += iprot->readI32(ecast759); + this->values[_i758] = (ClientCapability::type)ecast759; } xfer += iprot->readListEnd(); } @@ -18131,10 +18153,10 @@ uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->values.size())); - std::vector ::const_iterator _iter761; - for (_iter761 = this->values.begin(); _iter761 != this->values.end(); ++_iter761) + std::vector ::const_iterator _iter760; + for (_iter760 = this->values.begin(); _iter760 != this->values.end(); ++_iter760) { - xfer += oprot->writeI32((int32_t)(*_iter761)); + xfer += oprot->writeI32((int32_t)(*_iter760)); } xfer += oprot->writeListEnd(); } @@ -18150,11 +18172,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other762) { - values = other762.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other761) { + values = other761.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other763) { - values = other763.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other762) { + values = other762.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -18276,17 +18298,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other764) { +GetTableRequest::GetTableRequest(const GetTableRequest& other763) { + dbName = other763.dbName; + tblName = other763.tblName; + capabilities = other763.capabilities; + __isset = other763.__isset; +} +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other764) { dbName = other764.dbName; tblName = other764.tblName; capabilities = other764.capabilities; __isset = other764.__isset; -} -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other765) { - dbName = other765.dbName; - tblName = other765.tblName; - capabilities = other765.capabilities; - __isset = other765.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -18370,11 +18392,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other766) { - table = other766.table; +GetTableResult::GetTableResult(const GetTableResult& other765) { + table = other765.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other767) { - table = other767.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other766) { + table = other766.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -18437,14 +18459,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size768; - ::apache::thrift::protocol::TType _etype771; - xfer += iprot->readListBegin(_etype771, _size768); - this->tblNames.resize(_size768); - uint32_t _i772; - for (_i772 = 0; _i772 < _size768; ++_i772) + uint32_t _size767; + ::apache::thrift::protocol::TType _etype770; + xfer += iprot->readListBegin(_etype770, _size767); + this->tblNames.resize(_size767); + uint32_t _i771; + for (_i771 = 0; _i771 < _size767; ++_i771) { - xfer += iprot->readString(this->tblNames[_i772]); + xfer += iprot->readString(this->tblNames[_i771]); } xfer += iprot->readListEnd(); } @@ -18488,10 +18510,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tblNames.size())); - std::vector ::const_iterator _iter773; - for (_iter773 = this->tblNames.begin(); _iter773 != this->tblNames.end(); ++_iter773) + std::vector ::const_iterator _iter772; + for (_iter772 = this->tblNames.begin(); _iter772 != this->tblNames.end(); ++_iter772) { - xfer += oprot->writeString((*_iter773)); + xfer += oprot->writeString((*_iter772)); } xfer += oprot->writeListEnd(); } @@ -18515,17 +18537,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other774) { +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other773) { + dbName = other773.dbName; + tblNames = other773.tblNames; + capabilities = other773.capabilities; + __isset = other773.__isset; +} +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other774) { dbName = other774.dbName; tblNames = other774.tblNames; capabilities = other774.capabilities; __isset = other774.__isset; -} -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other775) { - dbName = other775.dbName; - tblNames = other775.tblNames; - capabilities = other775.capabilities; - __isset = other775.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -18572,14 +18594,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size776; - ::apache::thrift::protocol::TType _etype779; - xfer += iprot->readListBegin(_etype779, _size776); - this->tables.resize(_size776); - uint32_t _i780; - for (_i780 = 0; _i780 < _size776; ++_i780) + uint32_t _size775; + ::apache::thrift::protocol::TType _etype778; + xfer += iprot->readListBegin(_etype778, _size775); + this->tables.resize(_size775); + uint32_t _i779; + for (_i779 = 0; _i779 < _size775; ++_i779) { - xfer += this->tables[_i780].read(iprot); + xfer += this->tables[_i779].read(iprot); } xfer += iprot->readListEnd(); } @@ -18610,10 +18632,10 @@ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tables.size())); - std::vector
::const_iterator _iter781; - for (_iter781 = this->tables.begin(); _iter781 != this->tables.end(); ++_iter781) + std::vector
::const_iterator _iter780; + for (_iter780 = this->tables.begin(); _iter780 != this->tables.end(); ++_iter780) { - xfer += (*_iter781).write(oprot); + xfer += (*_iter780).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18629,11 +18651,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other782) { - tables = other782.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other781) { + tables = other781.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other783) { - tables = other783.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other782) { + tables = other782.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -18775,19 +18797,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other784) { +TableMeta::TableMeta(const TableMeta& other783) { + dbName = other783.dbName; + tableName = other783.tableName; + tableType = other783.tableType; + comments = other783.comments; + __isset = other783.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other784) { dbName = other784.dbName; tableName = other784.tableName; tableType = other784.tableType; comments = other784.comments; __isset = other784.__isset; -} -TableMeta& TableMeta::operator=(const TableMeta& other785) { - dbName = other785.dbName; - tableName = other785.tableName; - tableType = other785.tableType; - comments = other785.comments; - __isset = other785.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -18870,13 +18892,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other786) : TException() { +MetaException::MetaException(const MetaException& other785) : TException() { + message = other785.message; + __isset = other785.__isset; +} +MetaException& MetaException::operator=(const MetaException& other786) { message = other786.message; __isset = other786.__isset; -} -MetaException& MetaException::operator=(const MetaException& other787) { - message = other787.message; - __isset = other787.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -18967,13 +18989,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other788) : TException() { +UnknownTableException::UnknownTableException(const UnknownTableException& other787) : TException() { + message = other787.message; + __isset = other787.__isset; +} +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other788) { message = other788.message; __isset = other788.__isset; -} -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other789) { - message = other789.message; - __isset = other789.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -19064,13 +19086,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other790) : TException() { +UnknownDBException::UnknownDBException(const UnknownDBException& other789) : TException() { + message = other789.message; + __isset = other789.__isset; +} +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other790) { message = other790.message; __isset = other790.__isset; -} -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other791) { - message = other791.message; - __isset = other791.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -19161,13 +19183,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other792) : TException() { +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other791) : TException() { + message = other791.message; + __isset = other791.__isset; +} +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other792) { message = other792.message; __isset = other792.__isset; -} -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other793) { - message = other793.message; - __isset = other793.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -19258,13 +19280,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other794) : TException() { +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other793) : TException() { + message = other793.message; + __isset = other793.__isset; +} +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other794) { message = other794.message; __isset = other794.__isset; -} -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other795) { - message = other795.message; - __isset = other795.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -19355,13 +19377,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other796) : TException() { +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other795) : TException() { + message = other795.message; + __isset = other795.__isset; +} +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other796) { message = other796.message; __isset = other796.__isset; -} -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other797) { - message = other797.message; - __isset = other797.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -19452,13 +19474,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other798) : TException() { +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other797) : TException() { + message = other797.message; + __isset = other797.__isset; +} +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other798) { message = other798.message; __isset = other798.__isset; -} -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other799) { - message = other799.message; - __isset = other799.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -19549,13 +19571,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other800) : TException() { +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other799) : TException() { + message = other799.message; + __isset = other799.__isset; +} +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other800) { message = other800.message; __isset = other800.__isset; -} -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other801) { - message = other801.message; - __isset = other801.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -19646,13 +19668,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other802) : TException() { +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other801) : TException() { + message = other801.message; + __isset = other801.__isset; +} +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other802) { message = other802.message; __isset = other802.__isset; -} -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other803) { - message = other803.message; - __isset = other803.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -19743,13 +19765,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other804) : TException() { +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other803) : TException() { + message = other803.message; + __isset = other803.__isset; +} +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other804) { message = other804.message; __isset = other804.__isset; -} -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other805) { - message = other805.message; - __isset = other805.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -19840,13 +19862,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other806) : TException() { +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other805) : TException() { + message = other805.message; + __isset = other805.__isset; +} +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other806) { message = other806.message; __isset = other806.__isset; -} -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other807) { - message = other807.message; - __isset = other807.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -19937,13 +19959,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other808) : TException() { +InvalidInputException::InvalidInputException(const InvalidInputException& other807) : TException() { + message = other807.message; + __isset = other807.__isset; +} +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other808) { message = other808.message; __isset = other808.__isset; -} -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other809) { - message = other809.message; - __isset = other809.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -20034,13 +20056,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other810) : TException() { +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other809) : TException() { + message = other809.message; + __isset = other809.__isset; +} +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other810) { message = other810.message; __isset = other810.__isset; -} -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other811) { - message = other811.message; - __isset = other811.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -20131,13 +20153,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other812) : TException() { +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other811) : TException() { + message = other811.message; + __isset = other811.__isset; +} +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other812) { message = other812.message; __isset = other812.__isset; -} -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other813) { - message = other813.message; - __isset = other813.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -20228,13 +20250,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other814) : TException() { +TxnOpenException::TxnOpenException(const TxnOpenException& other813) : TException() { + message = other813.message; + __isset = other813.__isset; +} +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other814) { message = other814.message; __isset = other814.__isset; -} -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other815) { - message = other815.message; - __isset = other815.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -20325,13 +20347,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other816) : TException() { +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other815) : TException() { + message = other815.message; + __isset = other815.__isset; +} +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other816) { message = other816.message; __isset = other816.__isset; -} -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other817) { - message = other817.message; - __isset = other817.__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 50c61a7..c21ded1 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -4935,22 +4935,25 @@ class GetOpenTxnsResponse { GetOpenTxnsResponse(const GetOpenTxnsResponse&); GetOpenTxnsResponse& operator=(const GetOpenTxnsResponse&); - GetOpenTxnsResponse() : txn_high_water_mark(0), min_open_txn(0) { + GetOpenTxnsResponse() : txn_high_water_mark(0), min_open_txn(0), abortedBits() { } virtual ~GetOpenTxnsResponse() throw(); int64_t txn_high_water_mark; - std::set open_txns; + std::vector open_txns; int64_t min_open_txn; + std::string abortedBits; _GetOpenTxnsResponse__isset __isset; void __set_txn_high_water_mark(const int64_t val); - void __set_open_txns(const std::set & val); + void __set_open_txns(const std::vector & val); void __set_min_open_txn(const int64_t val); + void __set_abortedBits(const std::string& val); + bool operator == (const GetOpenTxnsResponse & rhs) const { if (!(txn_high_water_mark == rhs.txn_high_water_mark)) @@ -4961,6 +4964,8 @@ class GetOpenTxnsResponse { return false; else if (__isset.min_open_txn && !(min_open_txn == rhs.min_open_txn)) return false; + if (!(abortedBits == rhs.abortedBits)) + return false; return true; } bool operator != (const GetOpenTxnsResponse &rhs) const { diff --git metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsResponse.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsResponse.java index 8230d38..2852310 100644 --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsResponse.java +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsResponse.java @@ -39,8 +39,9 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetOpenTxnsResponse"); private static final org.apache.thrift.protocol.TField TXN_HIGH_WATER_MARK_FIELD_DESC = new org.apache.thrift.protocol.TField("txn_high_water_mark", org.apache.thrift.protocol.TType.I64, (short)1); - private static final org.apache.thrift.protocol.TField OPEN_TXNS_FIELD_DESC = new org.apache.thrift.protocol.TField("open_txns", org.apache.thrift.protocol.TType.SET, (short)2); + private static final org.apache.thrift.protocol.TField OPEN_TXNS_FIELD_DESC = new org.apache.thrift.protocol.TField("open_txns", org.apache.thrift.protocol.TType.LIST, (short)2); private static final org.apache.thrift.protocol.TField MIN_OPEN_TXN_FIELD_DESC = new org.apache.thrift.protocol.TField("min_open_txn", org.apache.thrift.protocol.TType.I64, (short)3); + private static final org.apache.thrift.protocol.TField ABORTED_BITS_FIELD_DESC = new org.apache.thrift.protocol.TField("abortedBits", org.apache.thrift.protocol.TType.STRING, (short)4); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -49,14 +50,16 @@ } private long txn_high_water_mark; // required - private Set open_txns; // required + private List open_txns; // required private long min_open_txn; // optional + private ByteBuffer abortedBits; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { TXN_HIGH_WATER_MARK((short)1, "txn_high_water_mark"), OPEN_TXNS((short)2, "open_txns"), - MIN_OPEN_TXN((short)3, "min_open_txn"); + MIN_OPEN_TXN((short)3, "min_open_txn"), + ABORTED_BITS((short)4, "abortedBits"); private static final Map byName = new HashMap(); @@ -77,6 +80,8 @@ public static _Fields findByThriftId(int fieldId) { return OPEN_TXNS; case 3: // MIN_OPEN_TXN return MIN_OPEN_TXN; + case 4: // ABORTED_BITS + return ABORTED_BITS; default: return null; } @@ -127,10 +132,12 @@ public String getFieldName() { tmpMap.put(_Fields.TXN_HIGH_WATER_MARK, new org.apache.thrift.meta_data.FieldMetaData("txn_high_water_mark", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); tmpMap.put(_Fields.OPEN_TXNS, new org.apache.thrift.meta_data.FieldMetaData("open_txns", org.apache.thrift.TFieldRequirementType.REQUIRED, - new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, + 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.I64)))); tmpMap.put(_Fields.MIN_OPEN_TXN, new org.apache.thrift.meta_data.FieldMetaData("min_open_txn", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.ABORTED_BITS, new org.apache.thrift.meta_data.FieldMetaData("abortedBits", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetOpenTxnsResponse.class, metaDataMap); } @@ -140,12 +147,14 @@ public GetOpenTxnsResponse() { public GetOpenTxnsResponse( long txn_high_water_mark, - Set open_txns) + List open_txns, + ByteBuffer abortedBits) { this(); this.txn_high_water_mark = txn_high_water_mark; setTxn_high_water_markIsSet(true); this.open_txns = open_txns; + this.abortedBits = org.apache.thrift.TBaseHelper.copyBinary(abortedBits); } /** @@ -155,10 +164,13 @@ public GetOpenTxnsResponse(GetOpenTxnsResponse other) { __isset_bitfield = other.__isset_bitfield; this.txn_high_water_mark = other.txn_high_water_mark; if (other.isSetOpen_txns()) { - Set __this__open_txns = new HashSet(other.open_txns); + List __this__open_txns = new ArrayList(other.open_txns); this.open_txns = __this__open_txns; } this.min_open_txn = other.min_open_txn; + if (other.isSetAbortedBits()) { + this.abortedBits = org.apache.thrift.TBaseHelper.copyBinary(other.abortedBits); + } } public GetOpenTxnsResponse deepCopy() { @@ -172,6 +184,7 @@ public void clear() { this.open_txns = null; setMin_open_txnIsSet(false); this.min_open_txn = 0; + this.abortedBits = null; } public long getTxn_high_water_mark() { @@ -206,16 +219,16 @@ public int getOpen_txnsSize() { public void addToOpen_txns(long elem) { if (this.open_txns == null) { - this.open_txns = new HashSet(); + this.open_txns = new ArrayList(); } this.open_txns.add(elem); } - public Set getOpen_txns() { + public List getOpen_txns() { return this.open_txns; } - public void setOpen_txns(Set open_txns) { + public void setOpen_txns(List open_txns) { this.open_txns = open_txns; } @@ -256,6 +269,38 @@ public void setMin_open_txnIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MIN_OPEN_TXN_ISSET_ID, value); } + public byte[] getAbortedBits() { + setAbortedBits(org.apache.thrift.TBaseHelper.rightSize(abortedBits)); + return abortedBits == null ? null : abortedBits.array(); + } + + public ByteBuffer bufferForAbortedBits() { + return org.apache.thrift.TBaseHelper.copyBinary(abortedBits); + } + + public void setAbortedBits(byte[] abortedBits) { + this.abortedBits = abortedBits == null ? (ByteBuffer)null : ByteBuffer.wrap(Arrays.copyOf(abortedBits, abortedBits.length)); + } + + public void setAbortedBits(ByteBuffer abortedBits) { + this.abortedBits = org.apache.thrift.TBaseHelper.copyBinary(abortedBits); + } + + public void unsetAbortedBits() { + this.abortedBits = null; + } + + /** Returns true if field abortedBits is set (has been assigned a value) and false otherwise */ + public boolean isSetAbortedBits() { + return this.abortedBits != null; + } + + public void setAbortedBitsIsSet(boolean value) { + if (!value) { + this.abortedBits = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TXN_HIGH_WATER_MARK: @@ -270,7 +315,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetOpen_txns(); } else { - setOpen_txns((Set)value); + setOpen_txns((List)value); } break; @@ -282,6 +327,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case ABORTED_BITS: + if (value == null) { + unsetAbortedBits(); + } else { + setAbortedBits((ByteBuffer)value); + } + break; + } } @@ -296,6 +349,9 @@ public Object getFieldValue(_Fields field) { case MIN_OPEN_TXN: return getMin_open_txn(); + case ABORTED_BITS: + return getAbortedBits(); + } throw new IllegalStateException(); } @@ -313,6 +369,8 @@ public boolean isSet(_Fields field) { return isSetOpen_txns(); case MIN_OPEN_TXN: return isSetMin_open_txn(); + case ABORTED_BITS: + return isSetAbortedBits(); } throw new IllegalStateException(); } @@ -357,6 +415,15 @@ public boolean equals(GetOpenTxnsResponse that) { return false; } + boolean this_present_abortedBits = true && this.isSetAbortedBits(); + boolean that_present_abortedBits = true && that.isSetAbortedBits(); + if (this_present_abortedBits || that_present_abortedBits) { + if (!(this_present_abortedBits && that_present_abortedBits)) + return false; + if (!this.abortedBits.equals(that.abortedBits)) + return false; + } + return true; } @@ -379,6 +446,11 @@ public int hashCode() { if (present_min_open_txn) list.add(min_open_txn); + boolean present_abortedBits = true && (isSetAbortedBits()); + list.add(present_abortedBits); + if (present_abortedBits) + list.add(abortedBits); + return list.hashCode(); } @@ -420,6 +492,16 @@ public int compareTo(GetOpenTxnsResponse other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetAbortedBits()).compareTo(other.isSetAbortedBits()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAbortedBits()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.abortedBits, other.abortedBits); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -457,6 +539,14 @@ public String toString() { sb.append(this.min_open_txn); first = false; } + if (!first) sb.append(", "); + sb.append("abortedBits:"); + if (this.abortedBits == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.abortedBits, sb); + } + first = false; sb.append(")"); return sb.toString(); } @@ -471,6 +561,10 @@ public void validate() throws org.apache.thrift.TException { throw new org.apache.thrift.protocol.TProtocolException("Required field 'open_txns' is unset! Struct:" + toString()); } + if (!isSetAbortedBits()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'abortedBits' is unset! Struct:" + toString()); + } + // check for sub-struct validity } @@ -519,17 +613,17 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetOpenTxnsResponse } break; case 2: // OPEN_TXNS - if (schemeField.type == org.apache.thrift.protocol.TType.SET) { + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TSet _set468 = iprot.readSetBegin(); - struct.open_txns = new HashSet(2*_set468.size); + org.apache.thrift.protocol.TList _list468 = iprot.readListBegin(); + struct.open_txns = new ArrayList(_list468.size); long _elem469; - for (int _i470 = 0; _i470 < _set468.size; ++_i470) + for (int _i470 = 0; _i470 < _list468.size; ++_i470) { _elem469 = iprot.readI64(); struct.open_txns.add(_elem469); } - iprot.readSetEnd(); + iprot.readListEnd(); } struct.setOpen_txnsIsSet(true); } else { @@ -544,6 +638,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetOpenTxnsResponse org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 4: // ABORTED_BITS + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.abortedBits = iprot.readBinary(); + struct.setAbortedBitsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -563,12 +665,12 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetOpenTxnsRespons if (struct.open_txns != null) { oprot.writeFieldBegin(OPEN_TXNS_FIELD_DESC); { - oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, struct.open_txns.size())); + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.open_txns.size())); for (long _iter471 : struct.open_txns) { oprot.writeI64(_iter471); } - oprot.writeSetEnd(); + oprot.writeListEnd(); } oprot.writeFieldEnd(); } @@ -577,6 +679,11 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetOpenTxnsRespons oprot.writeI64(struct.min_open_txn); oprot.writeFieldEnd(); } + if (struct.abortedBits != null) { + oprot.writeFieldBegin(ABORTED_BITS_FIELD_DESC); + oprot.writeBinary(struct.abortedBits); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -602,6 +709,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetOpenTxnsResponse oprot.writeI64(_iter472); } } + oprot.writeBinary(struct.abortedBits); BitSet optionals = new BitSet(); if (struct.isSetMin_open_txn()) { optionals.set(0); @@ -618,16 +726,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetOpenTxnsResponse struct.txn_high_water_mark = iprot.readI64(); struct.setTxn_high_water_markIsSet(true); { - org.apache.thrift.protocol.TSet _set473 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.open_txns = new HashSet(2*_set473.size); + org.apache.thrift.protocol.TList _list473 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.open_txns = new ArrayList(_list473.size); long _elem474; - for (int _i475 = 0; _i475 < _set473.size; ++_i475) + for (int _i475 = 0; _i475 < _list473.size; ++_i475) { _elem474 = iprot.readI64(); struct.open_txns.add(_elem474); } } struct.setOpen_txnsIsSet(true); + struct.abortedBits = iprot.readBinary(); + struct.setAbortedBitsIsSet(true); BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { struct.min_open_txn = iprot.readI64(); diff --git metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 9bfc2b2..dc9b09b 100644 --- metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -11032,14 +11032,14 @@ class ThriftHiveMetastore_get_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size597 = 0; - $_etype600 = 0; - $xfer += $input->readListBegin($_etype600, $_size597); - for ($_i601 = 0; $_i601 < $_size597; ++$_i601) + $_size596 = 0; + $_etype599 = 0; + $xfer += $input->readListBegin($_etype599, $_size596); + for ($_i600 = 0; $_i600 < $_size596; ++$_i600) { - $elem602 = null; - $xfer += $input->readString($elem602); - $this->success []= $elem602; + $elem601 = null; + $xfer += $input->readString($elem601); + $this->success []= $elem601; } $xfer += $input->readListEnd(); } else { @@ -11075,9 +11075,9 @@ class ThriftHiveMetastore_get_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter603) + foreach ($this->success as $iter602) { - $xfer += $output->writeString($iter603); + $xfer += $output->writeString($iter602); } } $output->writeListEnd(); @@ -11208,14 +11208,14 @@ class ThriftHiveMetastore_get_all_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size604 = 0; - $_etype607 = 0; - $xfer += $input->readListBegin($_etype607, $_size604); - for ($_i608 = 0; $_i608 < $_size604; ++$_i608) + $_size603 = 0; + $_etype606 = 0; + $xfer += $input->readListBegin($_etype606, $_size603); + for ($_i607 = 0; $_i607 < $_size603; ++$_i607) { - $elem609 = null; - $xfer += $input->readString($elem609); - $this->success []= $elem609; + $elem608 = null; + $xfer += $input->readString($elem608); + $this->success []= $elem608; } $xfer += $input->readListEnd(); } else { @@ -11251,9 +11251,9 @@ class ThriftHiveMetastore_get_all_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter610) + foreach ($this->success as $iter609) { - $xfer += $output->writeString($iter610); + $xfer += $output->writeString($iter609); } } $output->writeListEnd(); @@ -12254,18 +12254,18 @@ class ThriftHiveMetastore_get_type_all_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size611 = 0; - $_ktype612 = 0; - $_vtype613 = 0; - $xfer += $input->readMapBegin($_ktype612, $_vtype613, $_size611); - for ($_i615 = 0; $_i615 < $_size611; ++$_i615) + $_size610 = 0; + $_ktype611 = 0; + $_vtype612 = 0; + $xfer += $input->readMapBegin($_ktype611, $_vtype612, $_size610); + for ($_i614 = 0; $_i614 < $_size610; ++$_i614) { - $key616 = ''; - $val617 = new \metastore\Type(); - $xfer += $input->readString($key616); - $val617 = new \metastore\Type(); - $xfer += $val617->read($input); - $this->success[$key616] = $val617; + $key615 = ''; + $val616 = new \metastore\Type(); + $xfer += $input->readString($key615); + $val616 = new \metastore\Type(); + $xfer += $val616->read($input); + $this->success[$key615] = $val616; } $xfer += $input->readMapEnd(); } else { @@ -12301,10 +12301,10 @@ class ThriftHiveMetastore_get_type_all_result { { $output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->success)); { - foreach ($this->success as $kiter618 => $viter619) + foreach ($this->success as $kiter617 => $viter618) { - $xfer += $output->writeString($kiter618); - $xfer += $viter619->write($output); + $xfer += $output->writeString($kiter617); + $xfer += $viter618->write($output); } } $output->writeMapEnd(); @@ -12508,15 +12508,15 @@ class ThriftHiveMetastore_get_fields_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size620 = 0; - $_etype623 = 0; - $xfer += $input->readListBegin($_etype623, $_size620); - for ($_i624 = 0; $_i624 < $_size620; ++$_i624) + $_size619 = 0; + $_etype622 = 0; + $xfer += $input->readListBegin($_etype622, $_size619); + for ($_i623 = 0; $_i623 < $_size619; ++$_i623) { - $elem625 = null; - $elem625 = new \metastore\FieldSchema(); - $xfer += $elem625->read($input); - $this->success []= $elem625; + $elem624 = null; + $elem624 = new \metastore\FieldSchema(); + $xfer += $elem624->read($input); + $this->success []= $elem624; } $xfer += $input->readListEnd(); } else { @@ -12568,9 +12568,9 @@ class ThriftHiveMetastore_get_fields_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter626) + foreach ($this->success as $iter625) { - $xfer += $iter626->write($output); + $xfer += $iter625->write($output); } } $output->writeListEnd(); @@ -12812,15 +12812,15 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size627 = 0; - $_etype630 = 0; - $xfer += $input->readListBegin($_etype630, $_size627); - for ($_i631 = 0; $_i631 < $_size627; ++$_i631) + $_size626 = 0; + $_etype629 = 0; + $xfer += $input->readListBegin($_etype629, $_size626); + for ($_i630 = 0; $_i630 < $_size626; ++$_i630) { - $elem632 = null; - $elem632 = new \metastore\FieldSchema(); - $xfer += $elem632->read($input); - $this->success []= $elem632; + $elem631 = null; + $elem631 = new \metastore\FieldSchema(); + $xfer += $elem631->read($input); + $this->success []= $elem631; } $xfer += $input->readListEnd(); } else { @@ -12872,9 +12872,9 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter633) + foreach ($this->success as $iter632) { - $xfer += $iter633->write($output); + $xfer += $iter632->write($output); } } $output->writeListEnd(); @@ -13088,15 +13088,15 @@ class ThriftHiveMetastore_get_schema_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size634 = 0; - $_etype637 = 0; - $xfer += $input->readListBegin($_etype637, $_size634); - for ($_i638 = 0; $_i638 < $_size634; ++$_i638) + $_size633 = 0; + $_etype636 = 0; + $xfer += $input->readListBegin($_etype636, $_size633); + for ($_i637 = 0; $_i637 < $_size633; ++$_i637) { - $elem639 = null; - $elem639 = new \metastore\FieldSchema(); - $xfer += $elem639->read($input); - $this->success []= $elem639; + $elem638 = null; + $elem638 = new \metastore\FieldSchema(); + $xfer += $elem638->read($input); + $this->success []= $elem638; } $xfer += $input->readListEnd(); } else { @@ -13148,9 +13148,9 @@ class ThriftHiveMetastore_get_schema_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter640) + foreach ($this->success as $iter639) { - $xfer += $iter640->write($output); + $xfer += $iter639->write($output); } } $output->writeListEnd(); @@ -13392,15 +13392,15 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size641 = 0; - $_etype644 = 0; - $xfer += $input->readListBegin($_etype644, $_size641); - for ($_i645 = 0; $_i645 < $_size641; ++$_i645) + $_size640 = 0; + $_etype643 = 0; + $xfer += $input->readListBegin($_etype643, $_size640); + for ($_i644 = 0; $_i644 < $_size640; ++$_i644) { - $elem646 = null; - $elem646 = new \metastore\FieldSchema(); - $xfer += $elem646->read($input); - $this->success []= $elem646; + $elem645 = null; + $elem645 = new \metastore\FieldSchema(); + $xfer += $elem645->read($input); + $this->success []= $elem645; } $xfer += $input->readListEnd(); } else { @@ -13452,9 +13452,9 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter647) + foreach ($this->success as $iter646) { - $xfer += $iter647->write($output); + $xfer += $iter646->write($output); } } $output->writeListEnd(); @@ -14062,15 +14062,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 2: if ($ftype == TType::LST) { $this->primaryKeys = array(); - $_size648 = 0; - $_etype651 = 0; - $xfer += $input->readListBegin($_etype651, $_size648); - for ($_i652 = 0; $_i652 < $_size648; ++$_i652) + $_size647 = 0; + $_etype650 = 0; + $xfer += $input->readListBegin($_etype650, $_size647); + for ($_i651 = 0; $_i651 < $_size647; ++$_i651) { - $elem653 = null; - $elem653 = new \metastore\SQLPrimaryKey(); - $xfer += $elem653->read($input); - $this->primaryKeys []= $elem653; + $elem652 = null; + $elem652 = new \metastore\SQLPrimaryKey(); + $xfer += $elem652->read($input); + $this->primaryKeys []= $elem652; } $xfer += $input->readListEnd(); } else { @@ -14080,15 +14080,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 3: if ($ftype == TType::LST) { $this->foreignKeys = array(); - $_size654 = 0; - $_etype657 = 0; - $xfer += $input->readListBegin($_etype657, $_size654); - for ($_i658 = 0; $_i658 < $_size654; ++$_i658) + $_size653 = 0; + $_etype656 = 0; + $xfer += $input->readListBegin($_etype656, $_size653); + for ($_i657 = 0; $_i657 < $_size653; ++$_i657) { - $elem659 = null; - $elem659 = new \metastore\SQLForeignKey(); - $xfer += $elem659->read($input); - $this->foreignKeys []= $elem659; + $elem658 = null; + $elem658 = new \metastore\SQLForeignKey(); + $xfer += $elem658->read($input); + $this->foreignKeys []= $elem658; } $xfer += $input->readListEnd(); } else { @@ -14124,9 +14124,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->primaryKeys)); { - foreach ($this->primaryKeys as $iter660) + foreach ($this->primaryKeys as $iter659) { - $xfer += $iter660->write($output); + $xfer += $iter659->write($output); } } $output->writeListEnd(); @@ -14141,9 +14141,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->foreignKeys)); { - foreach ($this->foreignKeys as $iter661) + foreach ($this->foreignKeys as $iter660) { - $xfer += $iter661->write($output); + $xfer += $iter660->write($output); } } $output->writeListEnd(); @@ -15489,14 +15489,14 @@ class ThriftHiveMetastore_get_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size662 = 0; - $_etype665 = 0; - $xfer += $input->readListBegin($_etype665, $_size662); - for ($_i666 = 0; $_i666 < $_size662; ++$_i666) + $_size661 = 0; + $_etype664 = 0; + $xfer += $input->readListBegin($_etype664, $_size661); + for ($_i665 = 0; $_i665 < $_size661; ++$_i665) { - $elem667 = null; - $xfer += $input->readString($elem667); - $this->success []= $elem667; + $elem666 = null; + $xfer += $input->readString($elem666); + $this->success []= $elem666; } $xfer += $input->readListEnd(); } else { @@ -15532,9 +15532,9 @@ class ThriftHiveMetastore_get_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter668) + foreach ($this->success as $iter667) { - $xfer += $output->writeString($iter668); + $xfer += $output->writeString($iter667); } } $output->writeListEnd(); @@ -15736,14 +15736,14 @@ class ThriftHiveMetastore_get_tables_by_type_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size669 = 0; - $_etype672 = 0; - $xfer += $input->readListBegin($_etype672, $_size669); - for ($_i673 = 0; $_i673 < $_size669; ++$_i673) + $_size668 = 0; + $_etype671 = 0; + $xfer += $input->readListBegin($_etype671, $_size668); + for ($_i672 = 0; $_i672 < $_size668; ++$_i672) { - $elem674 = null; - $xfer += $input->readString($elem674); - $this->success []= $elem674; + $elem673 = null; + $xfer += $input->readString($elem673); + $this->success []= $elem673; } $xfer += $input->readListEnd(); } else { @@ -15779,9 +15779,9 @@ class ThriftHiveMetastore_get_tables_by_type_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter675) + foreach ($this->success as $iter674) { - $xfer += $output->writeString($iter675); + $xfer += $output->writeString($iter674); } } $output->writeListEnd(); @@ -15886,14 +15886,14 @@ class ThriftHiveMetastore_get_table_meta_args { case 3: if ($ftype == TType::LST) { $this->tbl_types = array(); - $_size676 = 0; - $_etype679 = 0; - $xfer += $input->readListBegin($_etype679, $_size676); - for ($_i680 = 0; $_i680 < $_size676; ++$_i680) + $_size675 = 0; + $_etype678 = 0; + $xfer += $input->readListBegin($_etype678, $_size675); + for ($_i679 = 0; $_i679 < $_size675; ++$_i679) { - $elem681 = null; - $xfer += $input->readString($elem681); - $this->tbl_types []= $elem681; + $elem680 = null; + $xfer += $input->readString($elem680); + $this->tbl_types []= $elem680; } $xfer += $input->readListEnd(); } else { @@ -15931,9 +15931,9 @@ class ThriftHiveMetastore_get_table_meta_args { { $output->writeListBegin(TType::STRING, count($this->tbl_types)); { - foreach ($this->tbl_types as $iter682) + foreach ($this->tbl_types as $iter681) { - $xfer += $output->writeString($iter682); + $xfer += $output->writeString($iter681); } } $output->writeListEnd(); @@ -16010,15 +16010,15 @@ class ThriftHiveMetastore_get_table_meta_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size683 = 0; - $_etype686 = 0; - $xfer += $input->readListBegin($_etype686, $_size683); - for ($_i687 = 0; $_i687 < $_size683; ++$_i687) + $_size682 = 0; + $_etype685 = 0; + $xfer += $input->readListBegin($_etype685, $_size682); + for ($_i686 = 0; $_i686 < $_size682; ++$_i686) { - $elem688 = null; - $elem688 = new \metastore\TableMeta(); - $xfer += $elem688->read($input); - $this->success []= $elem688; + $elem687 = null; + $elem687 = new \metastore\TableMeta(); + $xfer += $elem687->read($input); + $this->success []= $elem687; } $xfer += $input->readListEnd(); } else { @@ -16054,9 +16054,9 @@ class ThriftHiveMetastore_get_table_meta_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter689) + foreach ($this->success as $iter688) { - $xfer += $iter689->write($output); + $xfer += $iter688->write($output); } } $output->writeListEnd(); @@ -16212,14 +16212,14 @@ class ThriftHiveMetastore_get_all_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size690 = 0; - $_etype693 = 0; - $xfer += $input->readListBegin($_etype693, $_size690); - for ($_i694 = 0; $_i694 < $_size690; ++$_i694) + $_size689 = 0; + $_etype692 = 0; + $xfer += $input->readListBegin($_etype692, $_size689); + for ($_i693 = 0; $_i693 < $_size689; ++$_i693) { - $elem695 = null; - $xfer += $input->readString($elem695); - $this->success []= $elem695; + $elem694 = null; + $xfer += $input->readString($elem694); + $this->success []= $elem694; } $xfer += $input->readListEnd(); } else { @@ -16255,9 +16255,9 @@ class ThriftHiveMetastore_get_all_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter696) + foreach ($this->success as $iter695) { - $xfer += $output->writeString($iter696); + $xfer += $output->writeString($iter695); } } $output->writeListEnd(); @@ -16572,14 +16572,14 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { case 2: if ($ftype == TType::LST) { $this->tbl_names = array(); - $_size697 = 0; - $_etype700 = 0; - $xfer += $input->readListBegin($_etype700, $_size697); - for ($_i701 = 0; $_i701 < $_size697; ++$_i701) + $_size696 = 0; + $_etype699 = 0; + $xfer += $input->readListBegin($_etype699, $_size696); + for ($_i700 = 0; $_i700 < $_size696; ++$_i700) { - $elem702 = null; - $xfer += $input->readString($elem702); - $this->tbl_names []= $elem702; + $elem701 = null; + $xfer += $input->readString($elem701); + $this->tbl_names []= $elem701; } $xfer += $input->readListEnd(); } else { @@ -16612,9 +16612,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter703) + foreach ($this->tbl_names as $iter702) { - $xfer += $output->writeString($iter703); + $xfer += $output->writeString($iter702); } } $output->writeListEnd(); @@ -16679,15 +16679,15 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size704 = 0; - $_etype707 = 0; - $xfer += $input->readListBegin($_etype707, $_size704); - for ($_i708 = 0; $_i708 < $_size704; ++$_i708) + $_size703 = 0; + $_etype706 = 0; + $xfer += $input->readListBegin($_etype706, $_size703); + for ($_i707 = 0; $_i707 < $_size703; ++$_i707) { - $elem709 = null; - $elem709 = new \metastore\Table(); - $xfer += $elem709->read($input); - $this->success []= $elem709; + $elem708 = null; + $elem708 = new \metastore\Table(); + $xfer += $elem708->read($input); + $this->success []= $elem708; } $xfer += $input->readListEnd(); } else { @@ -16715,9 +16715,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter710) + foreach ($this->success as $iter709) { - $xfer += $iter710->write($output); + $xfer += $iter709->write($output); } } $output->writeListEnd(); @@ -17383,14 +17383,14 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size711 = 0; - $_etype714 = 0; - $xfer += $input->readListBegin($_etype714, $_size711); - for ($_i715 = 0; $_i715 < $_size711; ++$_i715) + $_size710 = 0; + $_etype713 = 0; + $xfer += $input->readListBegin($_etype713, $_size710); + for ($_i714 = 0; $_i714 < $_size710; ++$_i714) { - $elem716 = null; - $xfer += $input->readString($elem716); - $this->success []= $elem716; + $elem715 = null; + $xfer += $input->readString($elem715); + $this->success []= $elem715; } $xfer += $input->readListEnd(); } else { @@ -17442,9 +17442,9 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter717) + foreach ($this->success as $iter716) { - $xfer += $output->writeString($iter717); + $xfer += $output->writeString($iter716); } } $output->writeListEnd(); @@ -18757,15 +18757,15 @@ class ThriftHiveMetastore_add_partitions_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size718 = 0; - $_etype721 = 0; - $xfer += $input->readListBegin($_etype721, $_size718); - for ($_i722 = 0; $_i722 < $_size718; ++$_i722) + $_size717 = 0; + $_etype720 = 0; + $xfer += $input->readListBegin($_etype720, $_size717); + for ($_i721 = 0; $_i721 < $_size717; ++$_i721) { - $elem723 = null; - $elem723 = new \metastore\Partition(); - $xfer += $elem723->read($input); - $this->new_parts []= $elem723; + $elem722 = null; + $elem722 = new \metastore\Partition(); + $xfer += $elem722->read($input); + $this->new_parts []= $elem722; } $xfer += $input->readListEnd(); } else { @@ -18793,9 +18793,9 @@ class ThriftHiveMetastore_add_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter724) + foreach ($this->new_parts as $iter723) { - $xfer += $iter724->write($output); + $xfer += $iter723->write($output); } } $output->writeListEnd(); @@ -19010,15 +19010,15 @@ class ThriftHiveMetastore_add_partitions_pspec_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size725 = 0; - $_etype728 = 0; - $xfer += $input->readListBegin($_etype728, $_size725); - for ($_i729 = 0; $_i729 < $_size725; ++$_i729) + $_size724 = 0; + $_etype727 = 0; + $xfer += $input->readListBegin($_etype727, $_size724); + for ($_i728 = 0; $_i728 < $_size724; ++$_i728) { - $elem730 = null; - $elem730 = new \metastore\PartitionSpec(); - $xfer += $elem730->read($input); - $this->new_parts []= $elem730; + $elem729 = null; + $elem729 = new \metastore\PartitionSpec(); + $xfer += $elem729->read($input); + $this->new_parts []= $elem729; } $xfer += $input->readListEnd(); } else { @@ -19046,9 +19046,9 @@ class ThriftHiveMetastore_add_partitions_pspec_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter731) + foreach ($this->new_parts as $iter730) { - $xfer += $iter731->write($output); + $xfer += $iter730->write($output); } } $output->writeListEnd(); @@ -19298,14 +19298,14 @@ class ThriftHiveMetastore_append_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size732 = 0; - $_etype735 = 0; - $xfer += $input->readListBegin($_etype735, $_size732); - for ($_i736 = 0; $_i736 < $_size732; ++$_i736) + $_size731 = 0; + $_etype734 = 0; + $xfer += $input->readListBegin($_etype734, $_size731); + for ($_i735 = 0; $_i735 < $_size731; ++$_i735) { - $elem737 = null; - $xfer += $input->readString($elem737); - $this->part_vals []= $elem737; + $elem736 = null; + $xfer += $input->readString($elem736); + $this->part_vals []= $elem736; } $xfer += $input->readListEnd(); } else { @@ -19343,9 +19343,9 @@ class ThriftHiveMetastore_append_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter738) + foreach ($this->part_vals as $iter737) { - $xfer += $output->writeString($iter738); + $xfer += $output->writeString($iter737); } } $output->writeListEnd(); @@ -19847,14 +19847,14 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size739 = 0; - $_etype742 = 0; - $xfer += $input->readListBegin($_etype742, $_size739); - for ($_i743 = 0; $_i743 < $_size739; ++$_i743) + $_size738 = 0; + $_etype741 = 0; + $xfer += $input->readListBegin($_etype741, $_size738); + for ($_i742 = 0; $_i742 < $_size738; ++$_i742) { - $elem744 = null; - $xfer += $input->readString($elem744); - $this->part_vals []= $elem744; + $elem743 = null; + $xfer += $input->readString($elem743); + $this->part_vals []= $elem743; } $xfer += $input->readListEnd(); } else { @@ -19900,9 +19900,9 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter745) + foreach ($this->part_vals as $iter744) { - $xfer += $output->writeString($iter745); + $xfer += $output->writeString($iter744); } } $output->writeListEnd(); @@ -20756,14 +20756,14 @@ class ThriftHiveMetastore_drop_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size746 = 0; - $_etype749 = 0; - $xfer += $input->readListBegin($_etype749, $_size746); - for ($_i750 = 0; $_i750 < $_size746; ++$_i750) + $_size745 = 0; + $_etype748 = 0; + $xfer += $input->readListBegin($_etype748, $_size745); + for ($_i749 = 0; $_i749 < $_size745; ++$_i749) { - $elem751 = null; - $xfer += $input->readString($elem751); - $this->part_vals []= $elem751; + $elem750 = null; + $xfer += $input->readString($elem750); + $this->part_vals []= $elem750; } $xfer += $input->readListEnd(); } else { @@ -20808,9 +20808,9 @@ class ThriftHiveMetastore_drop_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter752) + foreach ($this->part_vals as $iter751) { - $xfer += $output->writeString($iter752); + $xfer += $output->writeString($iter751); } } $output->writeListEnd(); @@ -21063,14 +21063,14 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size753 = 0; - $_etype756 = 0; - $xfer += $input->readListBegin($_etype756, $_size753); - for ($_i757 = 0; $_i757 < $_size753; ++$_i757) + $_size752 = 0; + $_etype755 = 0; + $xfer += $input->readListBegin($_etype755, $_size752); + for ($_i756 = 0; $_i756 < $_size752; ++$_i756) { - $elem758 = null; - $xfer += $input->readString($elem758); - $this->part_vals []= $elem758; + $elem757 = null; + $xfer += $input->readString($elem757); + $this->part_vals []= $elem757; } $xfer += $input->readListEnd(); } else { @@ -21123,9 +21123,9 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter759) + foreach ($this->part_vals as $iter758) { - $xfer += $output->writeString($iter759); + $xfer += $output->writeString($iter758); } } $output->writeListEnd(); @@ -22139,14 +22139,14 @@ class ThriftHiveMetastore_get_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size760 = 0; - $_etype763 = 0; - $xfer += $input->readListBegin($_etype763, $_size760); - for ($_i764 = 0; $_i764 < $_size760; ++$_i764) + $_size759 = 0; + $_etype762 = 0; + $xfer += $input->readListBegin($_etype762, $_size759); + for ($_i763 = 0; $_i763 < $_size759; ++$_i763) { - $elem765 = null; - $xfer += $input->readString($elem765); - $this->part_vals []= $elem765; + $elem764 = null; + $xfer += $input->readString($elem764); + $this->part_vals []= $elem764; } $xfer += $input->readListEnd(); } else { @@ -22184,9 +22184,9 @@ class ThriftHiveMetastore_get_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter766) + foreach ($this->part_vals as $iter765) { - $xfer += $output->writeString($iter766); + $xfer += $output->writeString($iter765); } } $output->writeListEnd(); @@ -22428,17 +22428,17 @@ class ThriftHiveMetastore_exchange_partition_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size767 = 0; - $_ktype768 = 0; - $_vtype769 = 0; - $xfer += $input->readMapBegin($_ktype768, $_vtype769, $_size767); - for ($_i771 = 0; $_i771 < $_size767; ++$_i771) + $_size766 = 0; + $_ktype767 = 0; + $_vtype768 = 0; + $xfer += $input->readMapBegin($_ktype767, $_vtype768, $_size766); + for ($_i770 = 0; $_i770 < $_size766; ++$_i770) { - $key772 = ''; - $val773 = ''; - $xfer += $input->readString($key772); - $xfer += $input->readString($val773); - $this->partitionSpecs[$key772] = $val773; + $key771 = ''; + $val772 = ''; + $xfer += $input->readString($key771); + $xfer += $input->readString($val772); + $this->partitionSpecs[$key771] = $val772; } $xfer += $input->readMapEnd(); } else { @@ -22494,10 +22494,10 @@ class ThriftHiveMetastore_exchange_partition_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter774 => $viter775) + foreach ($this->partitionSpecs as $kiter773 => $viter774) { - $xfer += $output->writeString($kiter774); - $xfer += $output->writeString($viter775); + $xfer += $output->writeString($kiter773); + $xfer += $output->writeString($viter774); } } $output->writeMapEnd(); @@ -22809,17 +22809,17 @@ class ThriftHiveMetastore_exchange_partitions_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size776 = 0; - $_ktype777 = 0; - $_vtype778 = 0; - $xfer += $input->readMapBegin($_ktype777, $_vtype778, $_size776); - for ($_i780 = 0; $_i780 < $_size776; ++$_i780) + $_size775 = 0; + $_ktype776 = 0; + $_vtype777 = 0; + $xfer += $input->readMapBegin($_ktype776, $_vtype777, $_size775); + for ($_i779 = 0; $_i779 < $_size775; ++$_i779) { - $key781 = ''; - $val782 = ''; - $xfer += $input->readString($key781); - $xfer += $input->readString($val782); - $this->partitionSpecs[$key781] = $val782; + $key780 = ''; + $val781 = ''; + $xfer += $input->readString($key780); + $xfer += $input->readString($val781); + $this->partitionSpecs[$key780] = $val781; } $xfer += $input->readMapEnd(); } else { @@ -22875,10 +22875,10 @@ class ThriftHiveMetastore_exchange_partitions_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter783 => $viter784) + foreach ($this->partitionSpecs as $kiter782 => $viter783) { - $xfer += $output->writeString($kiter783); - $xfer += $output->writeString($viter784); + $xfer += $output->writeString($kiter782); + $xfer += $output->writeString($viter783); } } $output->writeMapEnd(); @@ -23011,15 +23011,15 @@ class ThriftHiveMetastore_exchange_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size785 = 0; - $_etype788 = 0; - $xfer += $input->readListBegin($_etype788, $_size785); - for ($_i789 = 0; $_i789 < $_size785; ++$_i789) + $_size784 = 0; + $_etype787 = 0; + $xfer += $input->readListBegin($_etype787, $_size784); + for ($_i788 = 0; $_i788 < $_size784; ++$_i788) { - $elem790 = null; - $elem790 = new \metastore\Partition(); - $xfer += $elem790->read($input); - $this->success []= $elem790; + $elem789 = null; + $elem789 = new \metastore\Partition(); + $xfer += $elem789->read($input); + $this->success []= $elem789; } $xfer += $input->readListEnd(); } else { @@ -23079,9 +23079,9 @@ class ThriftHiveMetastore_exchange_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter791) + foreach ($this->success as $iter790) { - $xfer += $iter791->write($output); + $xfer += $iter790->write($output); } } $output->writeListEnd(); @@ -23227,14 +23227,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size792 = 0; - $_etype795 = 0; - $xfer += $input->readListBegin($_etype795, $_size792); - for ($_i796 = 0; $_i796 < $_size792; ++$_i796) + $_size791 = 0; + $_etype794 = 0; + $xfer += $input->readListBegin($_etype794, $_size791); + for ($_i795 = 0; $_i795 < $_size791; ++$_i795) { - $elem797 = null; - $xfer += $input->readString($elem797); - $this->part_vals []= $elem797; + $elem796 = null; + $xfer += $input->readString($elem796); + $this->part_vals []= $elem796; } $xfer += $input->readListEnd(); } else { @@ -23251,14 +23251,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size798 = 0; - $_etype801 = 0; - $xfer += $input->readListBegin($_etype801, $_size798); - for ($_i802 = 0; $_i802 < $_size798; ++$_i802) + $_size797 = 0; + $_etype800 = 0; + $xfer += $input->readListBegin($_etype800, $_size797); + for ($_i801 = 0; $_i801 < $_size797; ++$_i801) { - $elem803 = null; - $xfer += $input->readString($elem803); - $this->group_names []= $elem803; + $elem802 = null; + $xfer += $input->readString($elem802); + $this->group_names []= $elem802; } $xfer += $input->readListEnd(); } else { @@ -23296,9 +23296,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter804) + foreach ($this->part_vals as $iter803) { - $xfer += $output->writeString($iter804); + $xfer += $output->writeString($iter803); } } $output->writeListEnd(); @@ -23318,9 +23318,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter805) + foreach ($this->group_names as $iter804) { - $xfer += $output->writeString($iter805); + $xfer += $output->writeString($iter804); } } $output->writeListEnd(); @@ -23911,15 +23911,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size806 = 0; - $_etype809 = 0; - $xfer += $input->readListBegin($_etype809, $_size806); - for ($_i810 = 0; $_i810 < $_size806; ++$_i810) + $_size805 = 0; + $_etype808 = 0; + $xfer += $input->readListBegin($_etype808, $_size805); + for ($_i809 = 0; $_i809 < $_size805; ++$_i809) { - $elem811 = null; - $elem811 = new \metastore\Partition(); - $xfer += $elem811->read($input); - $this->success []= $elem811; + $elem810 = null; + $elem810 = new \metastore\Partition(); + $xfer += $elem810->read($input); + $this->success []= $elem810; } $xfer += $input->readListEnd(); } else { @@ -23963,9 +23963,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter812) + foreach ($this->success as $iter811) { - $xfer += $iter812->write($output); + $xfer += $iter811->write($output); } } $output->writeListEnd(); @@ -24111,14 +24111,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size813 = 0; - $_etype816 = 0; - $xfer += $input->readListBegin($_etype816, $_size813); - for ($_i817 = 0; $_i817 < $_size813; ++$_i817) + $_size812 = 0; + $_etype815 = 0; + $xfer += $input->readListBegin($_etype815, $_size812); + for ($_i816 = 0; $_i816 < $_size812; ++$_i816) { - $elem818 = null; - $xfer += $input->readString($elem818); - $this->group_names []= $elem818; + $elem817 = null; + $xfer += $input->readString($elem817); + $this->group_names []= $elem817; } $xfer += $input->readListEnd(); } else { @@ -24166,9 +24166,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter819) + foreach ($this->group_names as $iter818) { - $xfer += $output->writeString($iter819); + $xfer += $output->writeString($iter818); } } $output->writeListEnd(); @@ -24257,15 +24257,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size820 = 0; - $_etype823 = 0; - $xfer += $input->readListBegin($_etype823, $_size820); - for ($_i824 = 0; $_i824 < $_size820; ++$_i824) + $_size819 = 0; + $_etype822 = 0; + $xfer += $input->readListBegin($_etype822, $_size819); + for ($_i823 = 0; $_i823 < $_size819; ++$_i823) { - $elem825 = null; - $elem825 = new \metastore\Partition(); - $xfer += $elem825->read($input); - $this->success []= $elem825; + $elem824 = null; + $elem824 = new \metastore\Partition(); + $xfer += $elem824->read($input); + $this->success []= $elem824; } $xfer += $input->readListEnd(); } else { @@ -24309,9 +24309,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter826) + foreach ($this->success as $iter825) { - $xfer += $iter826->write($output); + $xfer += $iter825->write($output); } } $output->writeListEnd(); @@ -24531,15 +24531,15 @@ class ThriftHiveMetastore_get_partitions_pspec_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size827 = 0; - $_etype830 = 0; - $xfer += $input->readListBegin($_etype830, $_size827); - for ($_i831 = 0; $_i831 < $_size827; ++$_i831) + $_size826 = 0; + $_etype829 = 0; + $xfer += $input->readListBegin($_etype829, $_size826); + for ($_i830 = 0; $_i830 < $_size826; ++$_i830) { - $elem832 = null; - $elem832 = new \metastore\PartitionSpec(); - $xfer += $elem832->read($input); - $this->success []= $elem832; + $elem831 = null; + $elem831 = new \metastore\PartitionSpec(); + $xfer += $elem831->read($input); + $this->success []= $elem831; } $xfer += $input->readListEnd(); } else { @@ -24583,9 +24583,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter833) + foreach ($this->success as $iter832) { - $xfer += $iter833->write($output); + $xfer += $iter832->write($output); } } $output->writeListEnd(); @@ -24792,14 +24792,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size834 = 0; - $_etype837 = 0; - $xfer += $input->readListBegin($_etype837, $_size834); - for ($_i838 = 0; $_i838 < $_size834; ++$_i838) + $_size833 = 0; + $_etype836 = 0; + $xfer += $input->readListBegin($_etype836, $_size833); + for ($_i837 = 0; $_i837 < $_size833; ++$_i837) { - $elem839 = null; - $xfer += $input->readString($elem839); - $this->success []= $elem839; + $elem838 = null; + $xfer += $input->readString($elem838); + $this->success []= $elem838; } $xfer += $input->readListEnd(); } else { @@ -24835,9 +24835,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter840) + foreach ($this->success as $iter839) { - $xfer += $output->writeString($iter840); + $xfer += $output->writeString($iter839); } } $output->writeListEnd(); @@ -24953,14 +24953,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size841 = 0; - $_etype844 = 0; - $xfer += $input->readListBegin($_etype844, $_size841); - for ($_i845 = 0; $_i845 < $_size841; ++$_i845) + $_size840 = 0; + $_etype843 = 0; + $xfer += $input->readListBegin($_etype843, $_size840); + for ($_i844 = 0; $_i844 < $_size840; ++$_i844) { - $elem846 = null; - $xfer += $input->readString($elem846); - $this->part_vals []= $elem846; + $elem845 = null; + $xfer += $input->readString($elem845); + $this->part_vals []= $elem845; } $xfer += $input->readListEnd(); } else { @@ -25005,9 +25005,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter847) + foreach ($this->part_vals as $iter846) { - $xfer += $output->writeString($iter847); + $xfer += $output->writeString($iter846); } } $output->writeListEnd(); @@ -25101,15 +25101,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size848 = 0; - $_etype851 = 0; - $xfer += $input->readListBegin($_etype851, $_size848); - for ($_i852 = 0; $_i852 < $_size848; ++$_i852) + $_size847 = 0; + $_etype850 = 0; + $xfer += $input->readListBegin($_etype850, $_size847); + for ($_i851 = 0; $_i851 < $_size847; ++$_i851) { - $elem853 = null; - $elem853 = new \metastore\Partition(); - $xfer += $elem853->read($input); - $this->success []= $elem853; + $elem852 = null; + $elem852 = new \metastore\Partition(); + $xfer += $elem852->read($input); + $this->success []= $elem852; } $xfer += $input->readListEnd(); } else { @@ -25153,9 +25153,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter854) + foreach ($this->success as $iter853) { - $xfer += $iter854->write($output); + $xfer += $iter853->write($output); } } $output->writeListEnd(); @@ -25302,14 +25302,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size855 = 0; - $_etype858 = 0; - $xfer += $input->readListBegin($_etype858, $_size855); - for ($_i859 = 0; $_i859 < $_size855; ++$_i859) + $_size854 = 0; + $_etype857 = 0; + $xfer += $input->readListBegin($_etype857, $_size854); + for ($_i858 = 0; $_i858 < $_size854; ++$_i858) { - $elem860 = null; - $xfer += $input->readString($elem860); - $this->part_vals []= $elem860; + $elem859 = null; + $xfer += $input->readString($elem859); + $this->part_vals []= $elem859; } $xfer += $input->readListEnd(); } else { @@ -25333,14 +25333,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size861 = 0; - $_etype864 = 0; - $xfer += $input->readListBegin($_etype864, $_size861); - for ($_i865 = 0; $_i865 < $_size861; ++$_i865) + $_size860 = 0; + $_etype863 = 0; + $xfer += $input->readListBegin($_etype863, $_size860); + for ($_i864 = 0; $_i864 < $_size860; ++$_i864) { - $elem866 = null; - $xfer += $input->readString($elem866); - $this->group_names []= $elem866; + $elem865 = null; + $xfer += $input->readString($elem865); + $this->group_names []= $elem865; } $xfer += $input->readListEnd(); } else { @@ -25378,9 +25378,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter867) + foreach ($this->part_vals as $iter866) { - $xfer += $output->writeString($iter867); + $xfer += $output->writeString($iter866); } } $output->writeListEnd(); @@ -25405,9 +25405,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter868) + foreach ($this->group_names as $iter867) { - $xfer += $output->writeString($iter868); + $xfer += $output->writeString($iter867); } } $output->writeListEnd(); @@ -25496,15 +25496,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size869 = 0; - $_etype872 = 0; - $xfer += $input->readListBegin($_etype872, $_size869); - for ($_i873 = 0; $_i873 < $_size869; ++$_i873) + $_size868 = 0; + $_etype871 = 0; + $xfer += $input->readListBegin($_etype871, $_size868); + for ($_i872 = 0; $_i872 < $_size868; ++$_i872) { - $elem874 = null; - $elem874 = new \metastore\Partition(); - $xfer += $elem874->read($input); - $this->success []= $elem874; + $elem873 = null; + $elem873 = new \metastore\Partition(); + $xfer += $elem873->read($input); + $this->success []= $elem873; } $xfer += $input->readListEnd(); } else { @@ -25548,9 +25548,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter875) + foreach ($this->success as $iter874) { - $xfer += $iter875->write($output); + $xfer += $iter874->write($output); } } $output->writeListEnd(); @@ -25671,14 +25671,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size876 = 0; - $_etype879 = 0; - $xfer += $input->readListBegin($_etype879, $_size876); - for ($_i880 = 0; $_i880 < $_size876; ++$_i880) + $_size875 = 0; + $_etype878 = 0; + $xfer += $input->readListBegin($_etype878, $_size875); + for ($_i879 = 0; $_i879 < $_size875; ++$_i879) { - $elem881 = null; - $xfer += $input->readString($elem881); - $this->part_vals []= $elem881; + $elem880 = null; + $xfer += $input->readString($elem880); + $this->part_vals []= $elem880; } $xfer += $input->readListEnd(); } else { @@ -25723,9 +25723,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter882) + foreach ($this->part_vals as $iter881) { - $xfer += $output->writeString($iter882); + $xfer += $output->writeString($iter881); } } $output->writeListEnd(); @@ -25818,14 +25818,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size883 = 0; - $_etype886 = 0; - $xfer += $input->readListBegin($_etype886, $_size883); - for ($_i887 = 0; $_i887 < $_size883; ++$_i887) + $_size882 = 0; + $_etype885 = 0; + $xfer += $input->readListBegin($_etype885, $_size882); + for ($_i886 = 0; $_i886 < $_size882; ++$_i886) { - $elem888 = null; - $xfer += $input->readString($elem888); - $this->success []= $elem888; + $elem887 = null; + $xfer += $input->readString($elem887); + $this->success []= $elem887; } $xfer += $input->readListEnd(); } else { @@ -25869,9 +25869,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter889) + foreach ($this->success as $iter888) { - $xfer += $output->writeString($iter889); + $xfer += $output->writeString($iter888); } } $output->writeListEnd(); @@ -26114,15 +26114,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size890 = 0; - $_etype893 = 0; - $xfer += $input->readListBegin($_etype893, $_size890); - for ($_i894 = 0; $_i894 < $_size890; ++$_i894) + $_size889 = 0; + $_etype892 = 0; + $xfer += $input->readListBegin($_etype892, $_size889); + for ($_i893 = 0; $_i893 < $_size889; ++$_i893) { - $elem895 = null; - $elem895 = new \metastore\Partition(); - $xfer += $elem895->read($input); - $this->success []= $elem895; + $elem894 = null; + $elem894 = new \metastore\Partition(); + $xfer += $elem894->read($input); + $this->success []= $elem894; } $xfer += $input->readListEnd(); } else { @@ -26166,9 +26166,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter896) + foreach ($this->success as $iter895) { - $xfer += $iter896->write($output); + $xfer += $iter895->write($output); } } $output->writeListEnd(); @@ -26411,15 +26411,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size897 = 0; - $_etype900 = 0; - $xfer += $input->readListBegin($_etype900, $_size897); - for ($_i901 = 0; $_i901 < $_size897; ++$_i901) + $_size896 = 0; + $_etype899 = 0; + $xfer += $input->readListBegin($_etype899, $_size896); + for ($_i900 = 0; $_i900 < $_size896; ++$_i900) { - $elem902 = null; - $elem902 = new \metastore\PartitionSpec(); - $xfer += $elem902->read($input); - $this->success []= $elem902; + $elem901 = null; + $elem901 = new \metastore\PartitionSpec(); + $xfer += $elem901->read($input); + $this->success []= $elem901; } $xfer += $input->readListEnd(); } else { @@ -26463,9 +26463,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter903) + foreach ($this->success as $iter902) { - $xfer += $iter903->write($output); + $xfer += $iter902->write($output); } } $output->writeListEnd(); @@ -27031,14 +27031,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size904 = 0; - $_etype907 = 0; - $xfer += $input->readListBegin($_etype907, $_size904); - for ($_i908 = 0; $_i908 < $_size904; ++$_i908) + $_size903 = 0; + $_etype906 = 0; + $xfer += $input->readListBegin($_etype906, $_size903); + for ($_i907 = 0; $_i907 < $_size903; ++$_i907) { - $elem909 = null; - $xfer += $input->readString($elem909); - $this->names []= $elem909; + $elem908 = null; + $xfer += $input->readString($elem908); + $this->names []= $elem908; } $xfer += $input->readListEnd(); } else { @@ -27076,9 +27076,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter910) + foreach ($this->names as $iter909) { - $xfer += $output->writeString($iter910); + $xfer += $output->writeString($iter909); } } $output->writeListEnd(); @@ -27167,15 +27167,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size911 = 0; - $_etype914 = 0; - $xfer += $input->readListBegin($_etype914, $_size911); - for ($_i915 = 0; $_i915 < $_size911; ++$_i915) + $_size910 = 0; + $_etype913 = 0; + $xfer += $input->readListBegin($_etype913, $_size910); + for ($_i914 = 0; $_i914 < $_size910; ++$_i914) { - $elem916 = null; - $elem916 = new \metastore\Partition(); - $xfer += $elem916->read($input); - $this->success []= $elem916; + $elem915 = null; + $elem915 = new \metastore\Partition(); + $xfer += $elem915->read($input); + $this->success []= $elem915; } $xfer += $input->readListEnd(); } else { @@ -27219,9 +27219,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter917) + foreach ($this->success as $iter916) { - $xfer += $iter917->write($output); + $xfer += $iter916->write($output); } } $output->writeListEnd(); @@ -27560,15 +27560,15 @@ class ThriftHiveMetastore_alter_partitions_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size918 = 0; - $_etype921 = 0; - $xfer += $input->readListBegin($_etype921, $_size918); - for ($_i922 = 0; $_i922 < $_size918; ++$_i922) + $_size917 = 0; + $_etype920 = 0; + $xfer += $input->readListBegin($_etype920, $_size917); + for ($_i921 = 0; $_i921 < $_size917; ++$_i921) { - $elem923 = null; - $elem923 = new \metastore\Partition(); - $xfer += $elem923->read($input); - $this->new_parts []= $elem923; + $elem922 = null; + $elem922 = new \metastore\Partition(); + $xfer += $elem922->read($input); + $this->new_parts []= $elem922; } $xfer += $input->readListEnd(); } else { @@ -27606,9 +27606,9 @@ class ThriftHiveMetastore_alter_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter924) + foreach ($this->new_parts as $iter923) { - $xfer += $iter924->write($output); + $xfer += $iter923->write($output); } } $output->writeListEnd(); @@ -27823,15 +27823,15 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size925 = 0; - $_etype928 = 0; - $xfer += $input->readListBegin($_etype928, $_size925); - for ($_i929 = 0; $_i929 < $_size925; ++$_i929) + $_size924 = 0; + $_etype927 = 0; + $xfer += $input->readListBegin($_etype927, $_size924); + for ($_i928 = 0; $_i928 < $_size924; ++$_i928) { - $elem930 = null; - $elem930 = new \metastore\Partition(); - $xfer += $elem930->read($input); - $this->new_parts []= $elem930; + $elem929 = null; + $elem929 = new \metastore\Partition(); + $xfer += $elem929->read($input); + $this->new_parts []= $elem929; } $xfer += $input->readListEnd(); } else { @@ -27877,9 +27877,9 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter931) + foreach ($this->new_parts as $iter930) { - $xfer += $iter931->write($output); + $xfer += $iter930->write($output); } } $output->writeListEnd(); @@ -28357,14 +28357,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size932 = 0; - $_etype935 = 0; - $xfer += $input->readListBegin($_etype935, $_size932); - for ($_i936 = 0; $_i936 < $_size932; ++$_i936) + $_size931 = 0; + $_etype934 = 0; + $xfer += $input->readListBegin($_etype934, $_size931); + for ($_i935 = 0; $_i935 < $_size931; ++$_i935) { - $elem937 = null; - $xfer += $input->readString($elem937); - $this->part_vals []= $elem937; + $elem936 = null; + $xfer += $input->readString($elem936); + $this->part_vals []= $elem936; } $xfer += $input->readListEnd(); } else { @@ -28410,9 +28410,9 @@ class ThriftHiveMetastore_rename_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter938) + foreach ($this->part_vals as $iter937) { - $xfer += $output->writeString($iter938); + $xfer += $output->writeString($iter937); } } $output->writeListEnd(); @@ -28597,14 +28597,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size939 = 0; - $_etype942 = 0; - $xfer += $input->readListBegin($_etype942, $_size939); - for ($_i943 = 0; $_i943 < $_size939; ++$_i943) + $_size938 = 0; + $_etype941 = 0; + $xfer += $input->readListBegin($_etype941, $_size938); + for ($_i942 = 0; $_i942 < $_size938; ++$_i942) { - $elem944 = null; - $xfer += $input->readString($elem944); - $this->part_vals []= $elem944; + $elem943 = null; + $xfer += $input->readString($elem943); + $this->part_vals []= $elem943; } $xfer += $input->readListEnd(); } else { @@ -28639,9 +28639,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter945) + foreach ($this->part_vals as $iter944) { - $xfer += $output->writeString($iter945); + $xfer += $output->writeString($iter944); } } $output->writeListEnd(); @@ -29095,14 +29095,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size946 = 0; - $_etype949 = 0; - $xfer += $input->readListBegin($_etype949, $_size946); - for ($_i950 = 0; $_i950 < $_size946; ++$_i950) + $_size945 = 0; + $_etype948 = 0; + $xfer += $input->readListBegin($_etype948, $_size945); + for ($_i949 = 0; $_i949 < $_size945; ++$_i949) { - $elem951 = null; - $xfer += $input->readString($elem951); - $this->success []= $elem951; + $elem950 = null; + $xfer += $input->readString($elem950); + $this->success []= $elem950; } $xfer += $input->readListEnd(); } else { @@ -29138,9 +29138,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter952) + foreach ($this->success as $iter951) { - $xfer += $output->writeString($iter952); + $xfer += $output->writeString($iter951); } } $output->writeListEnd(); @@ -29300,17 +29300,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size953 = 0; - $_ktype954 = 0; - $_vtype955 = 0; - $xfer += $input->readMapBegin($_ktype954, $_vtype955, $_size953); - for ($_i957 = 0; $_i957 < $_size953; ++$_i957) + $_size952 = 0; + $_ktype953 = 0; + $_vtype954 = 0; + $xfer += $input->readMapBegin($_ktype953, $_vtype954, $_size952); + for ($_i956 = 0; $_i956 < $_size952; ++$_i956) { - $key958 = ''; - $val959 = ''; - $xfer += $input->readString($key958); - $xfer += $input->readString($val959); - $this->success[$key958] = $val959; + $key957 = ''; + $val958 = ''; + $xfer += $input->readString($key957); + $xfer += $input->readString($val958); + $this->success[$key957] = $val958; } $xfer += $input->readMapEnd(); } else { @@ -29346,10 +29346,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter960 => $viter961) + foreach ($this->success as $kiter959 => $viter960) { - $xfer += $output->writeString($kiter960); - $xfer += $output->writeString($viter961); + $xfer += $output->writeString($kiter959); + $xfer += $output->writeString($viter960); } } $output->writeMapEnd(); @@ -29469,17 +29469,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size962 = 0; - $_ktype963 = 0; - $_vtype964 = 0; - $xfer += $input->readMapBegin($_ktype963, $_vtype964, $_size962); - for ($_i966 = 0; $_i966 < $_size962; ++$_i966) + $_size961 = 0; + $_ktype962 = 0; + $_vtype963 = 0; + $xfer += $input->readMapBegin($_ktype962, $_vtype963, $_size961); + for ($_i965 = 0; $_i965 < $_size961; ++$_i965) { - $key967 = ''; - $val968 = ''; - $xfer += $input->readString($key967); - $xfer += $input->readString($val968); - $this->part_vals[$key967] = $val968; + $key966 = ''; + $val967 = ''; + $xfer += $input->readString($key966); + $xfer += $input->readString($val967); + $this->part_vals[$key966] = $val967; } $xfer += $input->readMapEnd(); } else { @@ -29524,10 +29524,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter969 => $viter970) + foreach ($this->part_vals as $kiter968 => $viter969) { - $xfer += $output->writeString($kiter969); - $xfer += $output->writeString($viter970); + $xfer += $output->writeString($kiter968); + $xfer += $output->writeString($viter969); } } $output->writeMapEnd(); @@ -29849,17 +29849,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size971 = 0; - $_ktype972 = 0; - $_vtype973 = 0; - $xfer += $input->readMapBegin($_ktype972, $_vtype973, $_size971); - for ($_i975 = 0; $_i975 < $_size971; ++$_i975) + $_size970 = 0; + $_ktype971 = 0; + $_vtype972 = 0; + $xfer += $input->readMapBegin($_ktype971, $_vtype972, $_size970); + for ($_i974 = 0; $_i974 < $_size970; ++$_i974) { - $key976 = ''; - $val977 = ''; - $xfer += $input->readString($key976); - $xfer += $input->readString($val977); - $this->part_vals[$key976] = $val977; + $key975 = ''; + $val976 = ''; + $xfer += $input->readString($key975); + $xfer += $input->readString($val976); + $this->part_vals[$key975] = $val976; } $xfer += $input->readMapEnd(); } else { @@ -29904,10 +29904,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter978 => $viter979) + foreach ($this->part_vals as $kiter977 => $viter978) { - $xfer += $output->writeString($kiter978); - $xfer += $output->writeString($viter979); + $xfer += $output->writeString($kiter977); + $xfer += $output->writeString($viter978); } } $output->writeMapEnd(); @@ -31381,15 +31381,15 @@ class ThriftHiveMetastore_get_indexes_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size980 = 0; - $_etype983 = 0; - $xfer += $input->readListBegin($_etype983, $_size980); - for ($_i984 = 0; $_i984 < $_size980; ++$_i984) + $_size979 = 0; + $_etype982 = 0; + $xfer += $input->readListBegin($_etype982, $_size979); + for ($_i983 = 0; $_i983 < $_size979; ++$_i983) { - $elem985 = null; - $elem985 = new \metastore\Index(); - $xfer += $elem985->read($input); - $this->success []= $elem985; + $elem984 = null; + $elem984 = new \metastore\Index(); + $xfer += $elem984->read($input); + $this->success []= $elem984; } $xfer += $input->readListEnd(); } else { @@ -31433,9 +31433,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter986) + foreach ($this->success as $iter985) { - $xfer += $iter986->write($output); + $xfer += $iter985->write($output); } } $output->writeListEnd(); @@ -31642,14 +31642,14 @@ class ThriftHiveMetastore_get_index_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size987 = 0; - $_etype990 = 0; - $xfer += $input->readListBegin($_etype990, $_size987); - for ($_i991 = 0; $_i991 < $_size987; ++$_i991) + $_size986 = 0; + $_etype989 = 0; + $xfer += $input->readListBegin($_etype989, $_size986); + for ($_i990 = 0; $_i990 < $_size986; ++$_i990) { - $elem992 = null; - $xfer += $input->readString($elem992); - $this->success []= $elem992; + $elem991 = null; + $xfer += $input->readString($elem991); + $this->success []= $elem991; } $xfer += $input->readListEnd(); } else { @@ -31685,9 +31685,9 @@ class ThriftHiveMetastore_get_index_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter993) + foreach ($this->success as $iter992) { - $xfer += $output->writeString($iter993); + $xfer += $output->writeString($iter992); } } $output->writeListEnd(); @@ -35581,14 +35581,14 @@ class ThriftHiveMetastore_get_functions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size994 = 0; - $_etype997 = 0; - $xfer += $input->readListBegin($_etype997, $_size994); - for ($_i998 = 0; $_i998 < $_size994; ++$_i998) + $_size993 = 0; + $_etype996 = 0; + $xfer += $input->readListBegin($_etype996, $_size993); + for ($_i997 = 0; $_i997 < $_size993; ++$_i997) { - $elem999 = null; - $xfer += $input->readString($elem999); - $this->success []= $elem999; + $elem998 = null; + $xfer += $input->readString($elem998); + $this->success []= $elem998; } $xfer += $input->readListEnd(); } else { @@ -35624,9 +35624,9 @@ class ThriftHiveMetastore_get_functions_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1000) + foreach ($this->success as $iter999) { - $xfer += $output->writeString($iter1000); + $xfer += $output->writeString($iter999); } } $output->writeListEnd(); @@ -36495,14 +36495,14 @@ class ThriftHiveMetastore_get_role_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1001 = 0; - $_etype1004 = 0; - $xfer += $input->readListBegin($_etype1004, $_size1001); - for ($_i1005 = 0; $_i1005 < $_size1001; ++$_i1005) + $_size1000 = 0; + $_etype1003 = 0; + $xfer += $input->readListBegin($_etype1003, $_size1000); + for ($_i1004 = 0; $_i1004 < $_size1000; ++$_i1004) { - $elem1006 = null; - $xfer += $input->readString($elem1006); - $this->success []= $elem1006; + $elem1005 = null; + $xfer += $input->readString($elem1005); + $this->success []= $elem1005; } $xfer += $input->readListEnd(); } else { @@ -36538,9 +36538,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1007) + foreach ($this->success as $iter1006) { - $xfer += $output->writeString($iter1007); + $xfer += $output->writeString($iter1006); } } $output->writeListEnd(); @@ -37231,15 +37231,15 @@ class ThriftHiveMetastore_list_roles_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1008 = 0; - $_etype1011 = 0; - $xfer += $input->readListBegin($_etype1011, $_size1008); - for ($_i1012 = 0; $_i1012 < $_size1008; ++$_i1012) + $_size1007 = 0; + $_etype1010 = 0; + $xfer += $input->readListBegin($_etype1010, $_size1007); + for ($_i1011 = 0; $_i1011 < $_size1007; ++$_i1011) { - $elem1013 = null; - $elem1013 = new \metastore\Role(); - $xfer += $elem1013->read($input); - $this->success []= $elem1013; + $elem1012 = null; + $elem1012 = new \metastore\Role(); + $xfer += $elem1012->read($input); + $this->success []= $elem1012; } $xfer += $input->readListEnd(); } else { @@ -37275,9 +37275,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1014) + foreach ($this->success as $iter1013) { - $xfer += $iter1014->write($output); + $xfer += $iter1013->write($output); } } $output->writeListEnd(); @@ -37939,14 +37939,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1015 = 0; - $_etype1018 = 0; - $xfer += $input->readListBegin($_etype1018, $_size1015); - for ($_i1019 = 0; $_i1019 < $_size1015; ++$_i1019) + $_size1014 = 0; + $_etype1017 = 0; + $xfer += $input->readListBegin($_etype1017, $_size1014); + for ($_i1018 = 0; $_i1018 < $_size1014; ++$_i1018) { - $elem1020 = null; - $xfer += $input->readString($elem1020); - $this->group_names []= $elem1020; + $elem1019 = null; + $xfer += $input->readString($elem1019); + $this->group_names []= $elem1019; } $xfer += $input->readListEnd(); } else { @@ -37987,9 +37987,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1021) + foreach ($this->group_names as $iter1020) { - $xfer += $output->writeString($iter1021); + $xfer += $output->writeString($iter1020); } } $output->writeListEnd(); @@ -38297,15 +38297,15 @@ class ThriftHiveMetastore_list_privileges_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1022 = 0; - $_etype1025 = 0; - $xfer += $input->readListBegin($_etype1025, $_size1022); - for ($_i1026 = 0; $_i1026 < $_size1022; ++$_i1026) + $_size1021 = 0; + $_etype1024 = 0; + $xfer += $input->readListBegin($_etype1024, $_size1021); + for ($_i1025 = 0; $_i1025 < $_size1021; ++$_i1025) { - $elem1027 = null; - $elem1027 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem1027->read($input); - $this->success []= $elem1027; + $elem1026 = null; + $elem1026 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem1026->read($input); + $this->success []= $elem1026; } $xfer += $input->readListEnd(); } else { @@ -38341,9 +38341,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1028) + foreach ($this->success as $iter1027) { - $xfer += $iter1028->write($output); + $xfer += $iter1027->write($output); } } $output->writeListEnd(); @@ -38975,14 +38975,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1029 = 0; - $_etype1032 = 0; - $xfer += $input->readListBegin($_etype1032, $_size1029); - for ($_i1033 = 0; $_i1033 < $_size1029; ++$_i1033) + $_size1028 = 0; + $_etype1031 = 0; + $xfer += $input->readListBegin($_etype1031, $_size1028); + for ($_i1032 = 0; $_i1032 < $_size1028; ++$_i1032) { - $elem1034 = null; - $xfer += $input->readString($elem1034); - $this->group_names []= $elem1034; + $elem1033 = null; + $xfer += $input->readString($elem1033); + $this->group_names []= $elem1033; } $xfer += $input->readListEnd(); } else { @@ -39015,9 +39015,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1035) + foreach ($this->group_names as $iter1034) { - $xfer += $output->writeString($iter1035); + $xfer += $output->writeString($iter1034); } } $output->writeListEnd(); @@ -39093,14 +39093,14 @@ class ThriftHiveMetastore_set_ugi_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1036 = 0; - $_etype1039 = 0; - $xfer += $input->readListBegin($_etype1039, $_size1036); - for ($_i1040 = 0; $_i1040 < $_size1036; ++$_i1040) + $_size1035 = 0; + $_etype1038 = 0; + $xfer += $input->readListBegin($_etype1038, $_size1035); + for ($_i1039 = 0; $_i1039 < $_size1035; ++$_i1039) { - $elem1041 = null; - $xfer += $input->readString($elem1041); - $this->success []= $elem1041; + $elem1040 = null; + $xfer += $input->readString($elem1040); + $this->success []= $elem1040; } $xfer += $input->readListEnd(); } else { @@ -39136,9 +39136,9 @@ class ThriftHiveMetastore_set_ugi_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1042) + foreach ($this->success as $iter1041) { - $xfer += $output->writeString($iter1042); + $xfer += $output->writeString($iter1041); } } $output->writeListEnd(); @@ -40255,14 +40255,14 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1043 = 0; - $_etype1046 = 0; - $xfer += $input->readListBegin($_etype1046, $_size1043); - for ($_i1047 = 0; $_i1047 < $_size1043; ++$_i1047) + $_size1042 = 0; + $_etype1045 = 0; + $xfer += $input->readListBegin($_etype1045, $_size1042); + for ($_i1046 = 0; $_i1046 < $_size1042; ++$_i1046) { - $elem1048 = null; - $xfer += $input->readString($elem1048); - $this->success []= $elem1048; + $elem1047 = null; + $xfer += $input->readString($elem1047); + $this->success []= $elem1047; } $xfer += $input->readListEnd(); } else { @@ -40290,9 +40290,9 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1049) + foreach ($this->success as $iter1048) { - $xfer += $output->writeString($iter1049); + $xfer += $output->writeString($iter1048); } } $output->writeListEnd(); @@ -40931,14 +40931,14 @@ class ThriftHiveMetastore_get_master_keys_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1050 = 0; - $_etype1053 = 0; - $xfer += $input->readListBegin($_etype1053, $_size1050); - for ($_i1054 = 0; $_i1054 < $_size1050; ++$_i1054) + $_size1049 = 0; + $_etype1052 = 0; + $xfer += $input->readListBegin($_etype1052, $_size1049); + for ($_i1053 = 0; $_i1053 < $_size1049; ++$_i1053) { - $elem1055 = null; - $xfer += $input->readString($elem1055); - $this->success []= $elem1055; + $elem1054 = null; + $xfer += $input->readString($elem1054); + $this->success []= $elem1054; } $xfer += $input->readListEnd(); } else { @@ -40966,9 +40966,9 @@ class ThriftHiveMetastore_get_master_keys_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1056) + foreach ($this->success as $iter1055) { - $xfer += $output->writeString($iter1056); + $xfer += $output->writeString($iter1055); } } $output->writeListEnd(); diff --git metastore/src/gen/thrift/gen-php/metastore/Types.php metastore/src/gen/thrift/gen-php/metastore/Types.php index 4a3bf85..74f0028 100644 --- metastore/src/gen/thrift/gen-php/metastore/Types.php +++ metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -12082,6 +12082,10 @@ class GetOpenTxnsResponse { * @var int */ public $min_open_txn = null; + /** + * @var string + */ + public $abortedBits = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -12092,7 +12096,7 @@ class GetOpenTxnsResponse { ), 2 => array( 'var' => 'open_txns', - 'type' => TType::SET, + 'type' => TType::LST, 'etype' => TType::I64, 'elem' => array( 'type' => TType::I64, @@ -12102,6 +12106,10 @@ class GetOpenTxnsResponse { 'var' => 'min_open_txn', 'type' => TType::I64, ), + 4 => array( + 'var' => 'abortedBits', + 'type' => TType::STRING, + ), ); } if (is_array($vals)) { @@ -12114,6 +12122,9 @@ class GetOpenTxnsResponse { if (isset($vals['min_open_txn'])) { $this->min_open_txn = $vals['min_open_txn']; } + if (isset($vals['abortedBits'])) { + $this->abortedBits = $vals['abortedBits']; + } } } @@ -12144,22 +12155,18 @@ class GetOpenTxnsResponse { } break; case 2: - if ($ftype == TType::SET) { + if ($ftype == TType::LST) { $this->open_txns = array(); $_size413 = 0; $_etype416 = 0; - $xfer += $input->readSetBegin($_etype416, $_size413); + $xfer += $input->readListBegin($_etype416, $_size413); for ($_i417 = 0; $_i417 < $_size413; ++$_i417) { $elem418 = null; $xfer += $input->readI64($elem418); - if (is_scalar($elem418)) { - $this->open_txns[$elem418] = true; - } else { - $this->open_txns []= $elem418; - } + $this->open_txns []= $elem418; } - $xfer += $input->readSetEnd(); + $xfer += $input->readListEnd(); } else { $xfer += $input->skip($ftype); } @@ -12171,6 +12178,13 @@ class GetOpenTxnsResponse { $xfer += $input->skip($ftype); } break; + case 4: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->abortedBits); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -12193,20 +12207,16 @@ class GetOpenTxnsResponse { if (!is_array($this->open_txns)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); } - $xfer += $output->writeFieldBegin('open_txns', TType::SET, 2); + $xfer += $output->writeFieldBegin('open_txns', TType::LST, 2); { - $output->writeSetBegin(TType::I64, count($this->open_txns)); + $output->writeListBegin(TType::I64, count($this->open_txns)); { - foreach ($this->open_txns as $iter419 => $iter420) + foreach ($this->open_txns as $iter419) { - if (is_scalar($iter420)) { $xfer += $output->writeI64($iter419); - } else { - $xfer += $output->writeI64($iter420); - } } } - $output->writeSetEnd(); + $output->writeListEnd(); } $xfer += $output->writeFieldEnd(); } @@ -12215,6 +12225,11 @@ class GetOpenTxnsResponse { $xfer += $output->writeI64($this->min_open_txn); $xfer += $output->writeFieldEnd(); } + if ($this->abortedBits !== null) { + $xfer += $output->writeFieldBegin('abortedBits', TType::STRING, 4); + $xfer += $output->writeString($this->abortedBits); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -12416,14 +12431,14 @@ class OpenTxnsResponse { case 1: if ($ftype == TType::LST) { $this->txn_ids = array(); - $_size421 = 0; - $_etype424 = 0; - $xfer += $input->readListBegin($_etype424, $_size421); - for ($_i425 = 0; $_i425 < $_size421; ++$_i425) + $_size420 = 0; + $_etype423 = 0; + $xfer += $input->readListBegin($_etype423, $_size420); + for ($_i424 = 0; $_i424 < $_size420; ++$_i424) { - $elem426 = null; - $xfer += $input->readI64($elem426); - $this->txn_ids []= $elem426; + $elem425 = null; + $xfer += $input->readI64($elem425); + $this->txn_ids []= $elem425; } $xfer += $input->readListEnd(); } else { @@ -12451,9 +12466,9 @@ class OpenTxnsResponse { { $output->writeListBegin(TType::I64, count($this->txn_ids)); { - foreach ($this->txn_ids as $iter427) + foreach ($this->txn_ids as $iter426) { - $xfer += $output->writeI64($iter427); + $xfer += $output->writeI64($iter426); } } $output->writeListEnd(); @@ -12592,14 +12607,14 @@ class AbortTxnsRequest { case 1: if ($ftype == TType::LST) { $this->txn_ids = array(); - $_size428 = 0; - $_etype431 = 0; - $xfer += $input->readListBegin($_etype431, $_size428); - for ($_i432 = 0; $_i432 < $_size428; ++$_i432) + $_size427 = 0; + $_etype430 = 0; + $xfer += $input->readListBegin($_etype430, $_size427); + for ($_i431 = 0; $_i431 < $_size427; ++$_i431) { - $elem433 = null; - $xfer += $input->readI64($elem433); - $this->txn_ids []= $elem433; + $elem432 = null; + $xfer += $input->readI64($elem432); + $this->txn_ids []= $elem432; } $xfer += $input->readListEnd(); } else { @@ -12627,9 +12642,9 @@ class AbortTxnsRequest { { $output->writeListBegin(TType::I64, count($this->txn_ids)); { - foreach ($this->txn_ids as $iter434) + foreach ($this->txn_ids as $iter433) { - $xfer += $output->writeI64($iter434); + $xfer += $output->writeI64($iter433); } } $output->writeListEnd(); @@ -13049,15 +13064,15 @@ class LockRequest { case 1: if ($ftype == TType::LST) { $this->component = array(); - $_size435 = 0; - $_etype438 = 0; - $xfer += $input->readListBegin($_etype438, $_size435); - for ($_i439 = 0; $_i439 < $_size435; ++$_i439) + $_size434 = 0; + $_etype437 = 0; + $xfer += $input->readListBegin($_etype437, $_size434); + for ($_i438 = 0; $_i438 < $_size434; ++$_i438) { - $elem440 = null; - $elem440 = new \metastore\LockComponent(); - $xfer += $elem440->read($input); - $this->component []= $elem440; + $elem439 = null; + $elem439 = new \metastore\LockComponent(); + $xfer += $elem439->read($input); + $this->component []= $elem439; } $xfer += $input->readListEnd(); } else { @@ -13113,9 +13128,9 @@ class LockRequest { { $output->writeListBegin(TType::STRUCT, count($this->component)); { - foreach ($this->component as $iter441) + foreach ($this->component as $iter440) { - $xfer += $iter441->write($output); + $xfer += $iter440->write($output); } } $output->writeListEnd(); @@ -14058,15 +14073,15 @@ class ShowLocksResponse { case 1: if ($ftype == TType::LST) { $this->locks = array(); - $_size442 = 0; - $_etype445 = 0; - $xfer += $input->readListBegin($_etype445, $_size442); - for ($_i446 = 0; $_i446 < $_size442; ++$_i446) + $_size441 = 0; + $_etype444 = 0; + $xfer += $input->readListBegin($_etype444, $_size441); + for ($_i445 = 0; $_i445 < $_size441; ++$_i445) { - $elem447 = null; - $elem447 = new \metastore\ShowLocksResponseElement(); - $xfer += $elem447->read($input); - $this->locks []= $elem447; + $elem446 = null; + $elem446 = new \metastore\ShowLocksResponseElement(); + $xfer += $elem446->read($input); + $this->locks []= $elem446; } $xfer += $input->readListEnd(); } else { @@ -14094,9 +14109,9 @@ class ShowLocksResponse { { $output->writeListBegin(TType::STRUCT, count($this->locks)); { - foreach ($this->locks as $iter448) + foreach ($this->locks as $iter447) { - $xfer += $iter448->write($output); + $xfer += $iter447->write($output); } } $output->writeListEnd(); @@ -14371,17 +14386,17 @@ class HeartbeatTxnRangeResponse { case 1: if ($ftype == TType::SET) { $this->aborted = array(); - $_size449 = 0; - $_etype452 = 0; - $xfer += $input->readSetBegin($_etype452, $_size449); - for ($_i453 = 0; $_i453 < $_size449; ++$_i453) + $_size448 = 0; + $_etype451 = 0; + $xfer += $input->readSetBegin($_etype451, $_size448); + for ($_i452 = 0; $_i452 < $_size448; ++$_i452) { - $elem454 = null; - $xfer += $input->readI64($elem454); - if (is_scalar($elem454)) { - $this->aborted[$elem454] = true; + $elem453 = null; + $xfer += $input->readI64($elem453); + if (is_scalar($elem453)) { + $this->aborted[$elem453] = true; } else { - $this->aborted []= $elem454; + $this->aborted []= $elem453; } } $xfer += $input->readSetEnd(); @@ -14392,17 +14407,17 @@ class HeartbeatTxnRangeResponse { case 2: if ($ftype == TType::SET) { $this->nosuch = array(); - $_size455 = 0; - $_etype458 = 0; - $xfer += $input->readSetBegin($_etype458, $_size455); - for ($_i459 = 0; $_i459 < $_size455; ++$_i459) + $_size454 = 0; + $_etype457 = 0; + $xfer += $input->readSetBegin($_etype457, $_size454); + for ($_i458 = 0; $_i458 < $_size454; ++$_i458) { - $elem460 = null; - $xfer += $input->readI64($elem460); - if (is_scalar($elem460)) { - $this->nosuch[$elem460] = true; + $elem459 = null; + $xfer += $input->readI64($elem459); + if (is_scalar($elem459)) { + $this->nosuch[$elem459] = true; } else { - $this->nosuch []= $elem460; + $this->nosuch []= $elem459; } } $xfer += $input->readSetEnd(); @@ -14431,12 +14446,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->aborted)); { - foreach ($this->aborted as $iter461 => $iter462) + foreach ($this->aborted as $iter460 => $iter461) { - if (is_scalar($iter462)) { - $xfer += $output->writeI64($iter461); + if (is_scalar($iter461)) { + $xfer += $output->writeI64($iter460); } else { - $xfer += $output->writeI64($iter462); + $xfer += $output->writeI64($iter461); } } } @@ -14452,12 +14467,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->nosuch)); { - foreach ($this->nosuch as $iter463 => $iter464) + foreach ($this->nosuch as $iter462 => $iter463) { - if (is_scalar($iter464)) { - $xfer += $output->writeI64($iter463); + if (is_scalar($iter463)) { + $xfer += $output->writeI64($iter462); } else { - $xfer += $output->writeI64($iter464); + $xfer += $output->writeI64($iter463); } } } @@ -14616,17 +14631,17 @@ class CompactionRequest { case 6: if ($ftype == TType::MAP) { $this->properties = array(); - $_size465 = 0; - $_ktype466 = 0; - $_vtype467 = 0; - $xfer += $input->readMapBegin($_ktype466, $_vtype467, $_size465); - for ($_i469 = 0; $_i469 < $_size465; ++$_i469) + $_size464 = 0; + $_ktype465 = 0; + $_vtype466 = 0; + $xfer += $input->readMapBegin($_ktype465, $_vtype466, $_size464); + for ($_i468 = 0; $_i468 < $_size464; ++$_i468) { - $key470 = ''; - $val471 = ''; - $xfer += $input->readString($key470); - $xfer += $input->readString($val471); - $this->properties[$key470] = $val471; + $key469 = ''; + $val470 = ''; + $xfer += $input->readString($key469); + $xfer += $input->readString($val470); + $this->properties[$key469] = $val470; } $xfer += $input->readMapEnd(); } else { @@ -14679,10 +14694,10 @@ class CompactionRequest { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->properties)); { - foreach ($this->properties as $kiter472 => $viter473) + foreach ($this->properties as $kiter471 => $viter472) { - $xfer += $output->writeString($kiter472); - $xfer += $output->writeString($viter473); + $xfer += $output->writeString($kiter471); + $xfer += $output->writeString($viter472); } } $output->writeMapEnd(); @@ -15269,15 +15284,15 @@ class ShowCompactResponse { case 1: if ($ftype == TType::LST) { $this->compacts = array(); - $_size474 = 0; - $_etype477 = 0; - $xfer += $input->readListBegin($_etype477, $_size474); - for ($_i478 = 0; $_i478 < $_size474; ++$_i478) + $_size473 = 0; + $_etype476 = 0; + $xfer += $input->readListBegin($_etype476, $_size473); + for ($_i477 = 0; $_i477 < $_size473; ++$_i477) { - $elem479 = null; - $elem479 = new \metastore\ShowCompactResponseElement(); - $xfer += $elem479->read($input); - $this->compacts []= $elem479; + $elem478 = null; + $elem478 = new \metastore\ShowCompactResponseElement(); + $xfer += $elem478->read($input); + $this->compacts []= $elem478; } $xfer += $input->readListEnd(); } else { @@ -15305,9 +15320,9 @@ class ShowCompactResponse { { $output->writeListBegin(TType::STRUCT, count($this->compacts)); { - foreach ($this->compacts as $iter480) + foreach ($this->compacts as $iter479) { - $xfer += $iter480->write($output); + $xfer += $iter479->write($output); } } $output->writeListEnd(); @@ -15436,14 +15451,14 @@ class AddDynamicPartitions { case 4: if ($ftype == TType::LST) { $this->partitionnames = array(); - $_size481 = 0; - $_etype484 = 0; - $xfer += $input->readListBegin($_etype484, $_size481); - for ($_i485 = 0; $_i485 < $_size481; ++$_i485) + $_size480 = 0; + $_etype483 = 0; + $xfer += $input->readListBegin($_etype483, $_size480); + for ($_i484 = 0; $_i484 < $_size480; ++$_i484) { - $elem486 = null; - $xfer += $input->readString($elem486); - $this->partitionnames []= $elem486; + $elem485 = null; + $xfer += $input->readString($elem485); + $this->partitionnames []= $elem485; } $xfer += $input->readListEnd(); } else { @@ -15493,9 +15508,9 @@ class AddDynamicPartitions { { $output->writeListBegin(TType::STRING, count($this->partitionnames)); { - foreach ($this->partitionnames as $iter487) + foreach ($this->partitionnames as $iter486) { - $xfer += $output->writeString($iter487); + $xfer += $output->writeString($iter486); } } $output->writeListEnd(); @@ -15876,15 +15891,15 @@ class NotificationEventResponse { case 1: if ($ftype == TType::LST) { $this->events = array(); - $_size488 = 0; - $_etype491 = 0; - $xfer += $input->readListBegin($_etype491, $_size488); - for ($_i492 = 0; $_i492 < $_size488; ++$_i492) + $_size487 = 0; + $_etype490 = 0; + $xfer += $input->readListBegin($_etype490, $_size487); + for ($_i491 = 0; $_i491 < $_size487; ++$_i491) { - $elem493 = null; - $elem493 = new \metastore\NotificationEvent(); - $xfer += $elem493->read($input); - $this->events []= $elem493; + $elem492 = null; + $elem492 = new \metastore\NotificationEvent(); + $xfer += $elem492->read($input); + $this->events []= $elem492; } $xfer += $input->readListEnd(); } else { @@ -15912,9 +15927,9 @@ class NotificationEventResponse { { $output->writeListBegin(TType::STRUCT, count($this->events)); { - foreach ($this->events as $iter494) + foreach ($this->events as $iter493) { - $xfer += $iter494->write($output); + $xfer += $iter493->write($output); } } $output->writeListEnd(); @@ -16086,14 +16101,14 @@ class InsertEventRequestData { case 2: if ($ftype == TType::LST) { $this->filesAdded = array(); - $_size495 = 0; - $_etype498 = 0; - $xfer += $input->readListBegin($_etype498, $_size495); - for ($_i499 = 0; $_i499 < $_size495; ++$_i499) + $_size494 = 0; + $_etype497 = 0; + $xfer += $input->readListBegin($_etype497, $_size494); + for ($_i498 = 0; $_i498 < $_size494; ++$_i498) { - $elem500 = null; - $xfer += $input->readString($elem500); - $this->filesAdded []= $elem500; + $elem499 = null; + $xfer += $input->readString($elem499); + $this->filesAdded []= $elem499; } $xfer += $input->readListEnd(); } else { @@ -16103,14 +16118,14 @@ class InsertEventRequestData { case 3: if ($ftype == TType::LST) { $this->filesAddedChecksum = array(); - $_size501 = 0; - $_etype504 = 0; - $xfer += $input->readListBegin($_etype504, $_size501); - for ($_i505 = 0; $_i505 < $_size501; ++$_i505) + $_size500 = 0; + $_etype503 = 0; + $xfer += $input->readListBegin($_etype503, $_size500); + for ($_i504 = 0; $_i504 < $_size500; ++$_i504) { - $elem506 = null; - $xfer += $input->readString($elem506); - $this->filesAddedChecksum []= $elem506; + $elem505 = null; + $xfer += $input->readString($elem505); + $this->filesAddedChecksum []= $elem505; } $xfer += $input->readListEnd(); } else { @@ -16143,9 +16158,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAdded)); { - foreach ($this->filesAdded as $iter507) + foreach ($this->filesAdded as $iter506) { - $xfer += $output->writeString($iter507); + $xfer += $output->writeString($iter506); } } $output->writeListEnd(); @@ -16160,9 +16175,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAddedChecksum)); { - foreach ($this->filesAddedChecksum as $iter508) + foreach ($this->filesAddedChecksum as $iter507) { - $xfer += $output->writeString($iter508); + $xfer += $output->writeString($iter507); } } $output->writeListEnd(); @@ -16380,14 +16395,14 @@ class FireEventRequest { case 5: if ($ftype == TType::LST) { $this->partitionVals = array(); - $_size509 = 0; - $_etype512 = 0; - $xfer += $input->readListBegin($_etype512, $_size509); - for ($_i513 = 0; $_i513 < $_size509; ++$_i513) + $_size508 = 0; + $_etype511 = 0; + $xfer += $input->readListBegin($_etype511, $_size508); + for ($_i512 = 0; $_i512 < $_size508; ++$_i512) { - $elem514 = null; - $xfer += $input->readString($elem514); - $this->partitionVals []= $elem514; + $elem513 = null; + $xfer += $input->readString($elem513); + $this->partitionVals []= $elem513; } $xfer += $input->readListEnd(); } else { @@ -16438,9 +16453,9 @@ class FireEventRequest { { $output->writeListBegin(TType::STRING, count($this->partitionVals)); { - foreach ($this->partitionVals as $iter515) + foreach ($this->partitionVals as $iter514) { - $xfer += $output->writeString($iter515); + $xfer += $output->writeString($iter514); } } $output->writeListEnd(); @@ -16668,18 +16683,18 @@ class GetFileMetadataByExprResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size516 = 0; - $_ktype517 = 0; - $_vtype518 = 0; - $xfer += $input->readMapBegin($_ktype517, $_vtype518, $_size516); - for ($_i520 = 0; $_i520 < $_size516; ++$_i520) + $_size515 = 0; + $_ktype516 = 0; + $_vtype517 = 0; + $xfer += $input->readMapBegin($_ktype516, $_vtype517, $_size515); + for ($_i519 = 0; $_i519 < $_size515; ++$_i519) { - $key521 = 0; - $val522 = new \metastore\MetadataPpdResult(); - $xfer += $input->readI64($key521); - $val522 = new \metastore\MetadataPpdResult(); - $xfer += $val522->read($input); - $this->metadata[$key521] = $val522; + $key520 = 0; + $val521 = new \metastore\MetadataPpdResult(); + $xfer += $input->readI64($key520); + $val521 = new \metastore\MetadataPpdResult(); + $xfer += $val521->read($input); + $this->metadata[$key520] = $val521; } $xfer += $input->readMapEnd(); } else { @@ -16714,10 +16729,10 @@ class GetFileMetadataByExprResult { { $output->writeMapBegin(TType::I64, TType::STRUCT, count($this->metadata)); { - foreach ($this->metadata as $kiter523 => $viter524) + foreach ($this->metadata as $kiter522 => $viter523) { - $xfer += $output->writeI64($kiter523); - $xfer += $viter524->write($output); + $xfer += $output->writeI64($kiter522); + $xfer += $viter523->write($output); } } $output->writeMapEnd(); @@ -16819,14 +16834,14 @@ class GetFileMetadataByExprRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size525 = 0; - $_etype528 = 0; - $xfer += $input->readListBegin($_etype528, $_size525); - for ($_i529 = 0; $_i529 < $_size525; ++$_i529) + $_size524 = 0; + $_etype527 = 0; + $xfer += $input->readListBegin($_etype527, $_size524); + for ($_i528 = 0; $_i528 < $_size524; ++$_i528) { - $elem530 = null; - $xfer += $input->readI64($elem530); - $this->fileIds []= $elem530; + $elem529 = null; + $xfer += $input->readI64($elem529); + $this->fileIds []= $elem529; } $xfer += $input->readListEnd(); } else { @@ -16875,9 +16890,9 @@ class GetFileMetadataByExprRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter531) + foreach ($this->fileIds as $iter530) { - $xfer += $output->writeI64($iter531); + $xfer += $output->writeI64($iter530); } } $output->writeListEnd(); @@ -16971,17 +16986,17 @@ class GetFileMetadataResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size532 = 0; - $_ktype533 = 0; - $_vtype534 = 0; - $xfer += $input->readMapBegin($_ktype533, $_vtype534, $_size532); - for ($_i536 = 0; $_i536 < $_size532; ++$_i536) + $_size531 = 0; + $_ktype532 = 0; + $_vtype533 = 0; + $xfer += $input->readMapBegin($_ktype532, $_vtype533, $_size531); + for ($_i535 = 0; $_i535 < $_size531; ++$_i535) { - $key537 = 0; - $val538 = ''; - $xfer += $input->readI64($key537); - $xfer += $input->readString($val538); - $this->metadata[$key537] = $val538; + $key536 = 0; + $val537 = ''; + $xfer += $input->readI64($key536); + $xfer += $input->readString($val537); + $this->metadata[$key536] = $val537; } $xfer += $input->readMapEnd(); } else { @@ -17016,10 +17031,10 @@ class GetFileMetadataResult { { $output->writeMapBegin(TType::I64, TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $kiter539 => $viter540) + foreach ($this->metadata as $kiter538 => $viter539) { - $xfer += $output->writeI64($kiter539); - $xfer += $output->writeString($viter540); + $xfer += $output->writeI64($kiter538); + $xfer += $output->writeString($viter539); } } $output->writeMapEnd(); @@ -17088,14 +17103,14 @@ class GetFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size541 = 0; - $_etype544 = 0; - $xfer += $input->readListBegin($_etype544, $_size541); - for ($_i545 = 0; $_i545 < $_size541; ++$_i545) + $_size540 = 0; + $_etype543 = 0; + $xfer += $input->readListBegin($_etype543, $_size540); + for ($_i544 = 0; $_i544 < $_size540; ++$_i544) { - $elem546 = null; - $xfer += $input->readI64($elem546); - $this->fileIds []= $elem546; + $elem545 = null; + $xfer += $input->readI64($elem545); + $this->fileIds []= $elem545; } $xfer += $input->readListEnd(); } else { @@ -17123,9 +17138,9 @@ class GetFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter547) + foreach ($this->fileIds as $iter546) { - $xfer += $output->writeI64($iter547); + $xfer += $output->writeI64($iter546); } } $output->writeListEnd(); @@ -17265,14 +17280,14 @@ class PutFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size548 = 0; - $_etype551 = 0; - $xfer += $input->readListBegin($_etype551, $_size548); - for ($_i552 = 0; $_i552 < $_size548; ++$_i552) + $_size547 = 0; + $_etype550 = 0; + $xfer += $input->readListBegin($_etype550, $_size547); + for ($_i551 = 0; $_i551 < $_size547; ++$_i551) { - $elem553 = null; - $xfer += $input->readI64($elem553); - $this->fileIds []= $elem553; + $elem552 = null; + $xfer += $input->readI64($elem552); + $this->fileIds []= $elem552; } $xfer += $input->readListEnd(); } else { @@ -17282,14 +17297,14 @@ class PutFileMetadataRequest { case 2: if ($ftype == TType::LST) { $this->metadata = array(); - $_size554 = 0; - $_etype557 = 0; - $xfer += $input->readListBegin($_etype557, $_size554); - for ($_i558 = 0; $_i558 < $_size554; ++$_i558) + $_size553 = 0; + $_etype556 = 0; + $xfer += $input->readListBegin($_etype556, $_size553); + for ($_i557 = 0; $_i557 < $_size553; ++$_i557) { - $elem559 = null; - $xfer += $input->readString($elem559); - $this->metadata []= $elem559; + $elem558 = null; + $xfer += $input->readString($elem558); + $this->metadata []= $elem558; } $xfer += $input->readListEnd(); } else { @@ -17324,9 +17339,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter560) + foreach ($this->fileIds as $iter559) { - $xfer += $output->writeI64($iter560); + $xfer += $output->writeI64($iter559); } } $output->writeListEnd(); @@ -17341,9 +17356,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $iter561) + foreach ($this->metadata as $iter560) { - $xfer += $output->writeString($iter561); + $xfer += $output->writeString($iter560); } } $output->writeListEnd(); @@ -17462,14 +17477,14 @@ class ClearFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size562 = 0; - $_etype565 = 0; - $xfer += $input->readListBegin($_etype565, $_size562); - for ($_i566 = 0; $_i566 < $_size562; ++$_i566) + $_size561 = 0; + $_etype564 = 0; + $xfer += $input->readListBegin($_etype564, $_size561); + for ($_i565 = 0; $_i565 < $_size561; ++$_i565) { - $elem567 = null; - $xfer += $input->readI64($elem567); - $this->fileIds []= $elem567; + $elem566 = null; + $xfer += $input->readI64($elem566); + $this->fileIds []= $elem566; } $xfer += $input->readListEnd(); } else { @@ -17497,9 +17512,9 @@ class ClearFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter568) + foreach ($this->fileIds as $iter567) { - $xfer += $output->writeI64($iter568); + $xfer += $output->writeI64($iter567); } } $output->writeListEnd(); @@ -17783,15 +17798,15 @@ class GetAllFunctionsResponse { case 1: if ($ftype == TType::LST) { $this->functions = array(); - $_size569 = 0; - $_etype572 = 0; - $xfer += $input->readListBegin($_etype572, $_size569); - for ($_i573 = 0; $_i573 < $_size569; ++$_i573) + $_size568 = 0; + $_etype571 = 0; + $xfer += $input->readListBegin($_etype571, $_size568); + for ($_i572 = 0; $_i572 < $_size568; ++$_i572) { - $elem574 = null; - $elem574 = new \metastore\Function(); - $xfer += $elem574->read($input); - $this->functions []= $elem574; + $elem573 = null; + $elem573 = new \metastore\Function(); + $xfer += $elem573->read($input); + $this->functions []= $elem573; } $xfer += $input->readListEnd(); } else { @@ -17819,9 +17834,9 @@ class GetAllFunctionsResponse { { $output->writeListBegin(TType::STRUCT, count($this->functions)); { - foreach ($this->functions as $iter575) + foreach ($this->functions as $iter574) { - $xfer += $iter575->write($output); + $xfer += $iter574->write($output); } } $output->writeListEnd(); @@ -17885,14 +17900,14 @@ class ClientCapabilities { case 1: if ($ftype == TType::LST) { $this->values = array(); - $_size576 = 0; - $_etype579 = 0; - $xfer += $input->readListBegin($_etype579, $_size576); - for ($_i580 = 0; $_i580 < $_size576; ++$_i580) + $_size575 = 0; + $_etype578 = 0; + $xfer += $input->readListBegin($_etype578, $_size575); + for ($_i579 = 0; $_i579 < $_size575; ++$_i579) { - $elem581 = null; - $xfer += $input->readI32($elem581); - $this->values []= $elem581; + $elem580 = null; + $xfer += $input->readI32($elem580); + $this->values []= $elem580; } $xfer += $input->readListEnd(); } else { @@ -17920,9 +17935,9 @@ class ClientCapabilities { { $output->writeListBegin(TType::I32, count($this->values)); { - foreach ($this->values as $iter582) + foreach ($this->values as $iter581) { - $xfer += $output->writeI32($iter582); + $xfer += $output->writeI32($iter581); } } $output->writeListEnd(); @@ -18222,14 +18237,14 @@ class GetTablesRequest { case 2: if ($ftype == TType::LST) { $this->tblNames = array(); - $_size583 = 0; - $_etype586 = 0; - $xfer += $input->readListBegin($_etype586, $_size583); - for ($_i587 = 0; $_i587 < $_size583; ++$_i587) + $_size582 = 0; + $_etype585 = 0; + $xfer += $input->readListBegin($_etype585, $_size582); + for ($_i586 = 0; $_i586 < $_size582; ++$_i586) { - $elem588 = null; - $xfer += $input->readString($elem588); - $this->tblNames []= $elem588; + $elem587 = null; + $xfer += $input->readString($elem587); + $this->tblNames []= $elem587; } $xfer += $input->readListEnd(); } else { @@ -18270,9 +18285,9 @@ class GetTablesRequest { { $output->writeListBegin(TType::STRING, count($this->tblNames)); { - foreach ($this->tblNames as $iter589) + foreach ($this->tblNames as $iter588) { - $xfer += $output->writeString($iter589); + $xfer += $output->writeString($iter588); } } $output->writeListEnd(); @@ -18345,15 +18360,15 @@ class GetTablesResult { case 1: if ($ftype == TType::LST) { $this->tables = array(); - $_size590 = 0; - $_etype593 = 0; - $xfer += $input->readListBegin($_etype593, $_size590); - for ($_i594 = 0; $_i594 < $_size590; ++$_i594) + $_size589 = 0; + $_etype592 = 0; + $xfer += $input->readListBegin($_etype592, $_size589); + for ($_i593 = 0; $_i593 < $_size589; ++$_i593) { - $elem595 = null; - $elem595 = new \metastore\Table(); - $xfer += $elem595->read($input); - $this->tables []= $elem595; + $elem594 = null; + $elem594 = new \metastore\Table(); + $xfer += $elem594->read($input); + $this->tables []= $elem594; } $xfer += $input->readListEnd(); } else { @@ -18381,9 +18396,9 @@ class GetTablesResult { { $output->writeListBegin(TType::STRUCT, count($this->tables)); { - foreach ($this->tables as $iter596) + foreach ($this->tables as $iter595) { - $xfer += $iter596->write($output); + $xfer += $iter595->write($output); } } $output->writeListEnd(); diff --git metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index 9480c85..f26cb5b 100644 --- metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -8315,19 +8315,22 @@ class GetOpenTxnsResponse: - txn_high_water_mark - open_txns - min_open_txn + - abortedBits """ thrift_spec = ( None, # 0 (1, TType.I64, 'txn_high_water_mark', None, None, ), # 1 - (2, TType.SET, 'open_txns', (TType.I64,None), None, ), # 2 + (2, TType.LIST, 'open_txns', (TType.I64,None), None, ), # 2 (3, TType.I64, 'min_open_txn', None, None, ), # 3 + (4, TType.STRING, 'abortedBits', None, None, ), # 4 ) - def __init__(self, txn_high_water_mark=None, open_txns=None, min_open_txn=None,): + def __init__(self, txn_high_water_mark=None, open_txns=None, min_open_txn=None, abortedBits=None,): self.txn_high_water_mark = txn_high_water_mark self.open_txns = open_txns self.min_open_txn = min_open_txn + self.abortedBits = abortedBits 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: @@ -8344,13 +8347,13 @@ def read(self, iprot): else: iprot.skip(ftype) elif fid == 2: - if ftype == TType.SET: - self.open_txns = set() - (_etype416, _size413) = iprot.readSetBegin() + if ftype == TType.LIST: + self.open_txns = [] + (_etype416, _size413) = iprot.readListBegin() for _i417 in xrange(_size413): _elem418 = iprot.readI64() - self.open_txns.add(_elem418) - iprot.readSetEnd() + self.open_txns.append(_elem418) + iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: @@ -8358,6 +8361,11 @@ def read(self, iprot): self.min_open_txn = iprot.readI64() else: iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRING: + self.abortedBits = iprot.readString() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -8373,16 +8381,20 @@ def write(self, oprot): oprot.writeI64(self.txn_high_water_mark) oprot.writeFieldEnd() if self.open_txns is not None: - oprot.writeFieldBegin('open_txns', TType.SET, 2) - oprot.writeSetBegin(TType.I64, len(self.open_txns)) + oprot.writeFieldBegin('open_txns', TType.LIST, 2) + oprot.writeListBegin(TType.I64, len(self.open_txns)) for iter419 in self.open_txns: oprot.writeI64(iter419) - oprot.writeSetEnd() + oprot.writeListEnd() oprot.writeFieldEnd() if self.min_open_txn is not None: oprot.writeFieldBegin('min_open_txn', TType.I64, 3) oprot.writeI64(self.min_open_txn) oprot.writeFieldEnd() + if self.abortedBits is not None: + oprot.writeFieldBegin('abortedBits', TType.STRING, 4) + oprot.writeString(self.abortedBits) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -8391,6 +8403,8 @@ def validate(self): raise TProtocol.TProtocolException(message='Required field txn_high_water_mark is unset!') if self.open_txns is None: raise TProtocol.TProtocolException(message='Required field open_txns is unset!') + if self.abortedBits is None: + raise TProtocol.TProtocolException(message='Required field abortedBits is unset!') return @@ -8399,6 +8413,7 @@ def __hash__(self): value = (value * 31) ^ hash(self.txn_high_water_mark) value = (value * 31) ^ hash(self.open_txns) value = (value * 31) ^ hash(self.min_open_txn) + value = (value * 31) ^ hash(self.abortedBits) 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 7766071..f1aa9a6 100644 --- metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -1856,11 +1856,13 @@ class GetOpenTxnsResponse TXN_HIGH_WATER_MARK = 1 OPEN_TXNS = 2 MIN_OPEN_TXN = 3 + ABORTEDBITS = 4 FIELDS = { TXN_HIGH_WATER_MARK => {:type => ::Thrift::Types::I64, :name => 'txn_high_water_mark'}, - OPEN_TXNS => {:type => ::Thrift::Types::SET, :name => 'open_txns', :element => {:type => ::Thrift::Types::I64}}, - MIN_OPEN_TXN => {:type => ::Thrift::Types::I64, :name => 'min_open_txn', :optional => true} + OPEN_TXNS => {:type => ::Thrift::Types::LIST, :name => 'open_txns', :element => {:type => ::Thrift::Types::I64}}, + MIN_OPEN_TXN => {:type => ::Thrift::Types::I64, :name => 'min_open_txn', :optional => true}, + ABORTEDBITS => {:type => ::Thrift::Types::STRING, :name => 'abortedBits', :binary => true} } def struct_fields; FIELDS; end @@ -1868,6 +1870,7 @@ class GetOpenTxnsResponse def validate raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field txn_high_water_mark is unset!') unless @txn_high_water_mark raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field open_txns is unset!') unless @open_txns + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field abortedBits is unset!') unless @abortedBits end ::Thrift::Struct.generate_accessors self 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 e138838..bd28a8b 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java @@ -52,6 +52,7 @@ import java.io.IOException; import java.io.PrintWriter; +import java.nio.ByteBuffer; import java.sql.*; import java.util.*; import java.util.concurrent.ConcurrentHashMap; @@ -394,23 +395,27 @@ public GetOpenTxnsResponse getOpenTxns() throws MetaException { "initialized, null record found in next_txn_id"); } close(rs); - Set openList = new HashSet(); + List openList = new ArrayList(); //need the WHERE clause below to ensure consistent results with READ_COMMITTED s = "select txn_id, txn_state from TXNS where txn_id <= " + hwm; LOG.debug("Going to execute query<" + s + ">"); rs = stmt.executeQuery(s); long minOpenTxn = Long.MAX_VALUE; + BitSet abortedBits = new BitSet(); while (rs.next()) { long txnId = rs.getLong(1); openList.add(txnId); char c = rs.getString(2).charAt(0); if(c == TXN_OPEN) { minOpenTxn = Math.min(minOpenTxn, txnId); + } else if (c == TXN_ABORTED) { + abortedBits.set(openList.size() - 1); } } LOG.debug("Going to rollback"); dbConn.rollback(); - GetOpenTxnsResponse otr = new GetOpenTxnsResponse(hwm, openList); + ByteBuffer byteBuffer = ByteBuffer.wrap(abortedBits.toByteArray()); + GetOpenTxnsResponse otr = new GetOpenTxnsResponse(hwm, openList, byteBuffer); if(minOpenTxn < Long.MAX_VALUE) { otr.setMin_open_txn(minOpenTxn); } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnUtils.java metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnUtils.java index 517eec3..f56f4f4 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnUtils.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/txn/TxnUtils.java @@ -32,9 +32,9 @@ import org.slf4j.LoggerFactory; import java.util.Arrays; +import java.util.BitSet; import java.util.List; import java.util.Map; -import java.util.Set; public class TxnUtils { private static final Logger LOG = LoggerFactory.getLogger(TxnUtils.class); @@ -51,18 +51,19 @@ */ public static ValidTxnList createValidReadTxnList(GetOpenTxnsResponse txns, long currentTxn) { long highWater = txns.getTxn_high_water_mark(); - Set open = txns.getOpen_txns(); + List open = txns.getOpen_txns(); + BitSet abortedBits = BitSet.valueOf(txns.getAbortedBits()); long[] exceptions = new long[open.size() - (currentTxn > 0 ? 1 : 0)]; - int i = 0; - for(long txn: open) { + for (int i = 0; i < open.size(); i++) { + long txn = open.get(i); if (currentTxn > 0 && currentTxn == txn) continue; exceptions[i++] = txn; } if(txns.isSetMin_open_txn()) { - return new ValidReadTxnList(exceptions, highWater, txns.getMin_open_txn()); + return new ValidReadTxnList(exceptions, abortedBits, highWater, txns.getMin_open_txn()); } else { - return new ValidReadTxnList(exceptions, highWater); + return new ValidReadTxnList(exceptions, abortedBits, highWater); } } diff --git ql/src/java/org/apache/hadoop/hive/ql/txn/compactor/Cleaner.java ql/src/java/org/apache/hadoop/hive/ql/txn/compactor/Cleaner.java index 23b1b7f..6adface 100644 --- ql/src/java/org/apache/hadoop/hive/ql/txn/compactor/Cleaner.java +++ ql/src/java/org/apache/hadoop/hive/ql/txn/compactor/Cleaner.java @@ -41,6 +41,7 @@ import java.io.IOException; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; +import java.util.BitSet; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -257,7 +258,7 @@ private void clean(CompactionInfo ci) throws MetaException { * unless ValidTxnList is "capped" at highestTxnId. */ final ValidTxnList txnList = ci.highestTxnId > 0 ? - new ValidReadTxnList(new long[0], ci.highestTxnId) : new ValidReadTxnList(); + new ValidReadTxnList(new long[0], new BitSet(), ci.highestTxnId) : new ValidReadTxnList(); if (runJobAsSelf(ci.runAs)) { removeFiles(location, txnList);