diff --git common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidCompactorTxnList.java index 334b93e..8f55354 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. @@ -40,11 +41,12 @@ public ValidCompactorTxnList() { } /** * @param abortedTxnList list of all aborted transactions + * @param abortedBits bitset marking whether the corresponding transaction is aborted * @param highWatermark highest committed transaction to be considered for compaction, * equivalently (lowest_open_txn - 1). */ - public ValidCompactorTxnList(long[] abortedTxnList, long highWatermark) { - super(abortedTxnList, highWatermark); + public ValidCompactorTxnList(long[] abortedTxnList, BitSet abortedBits, long highWatermark) { + super(abortedTxnList, abortedBits, highWatermark); // abortedBits should be all true as everything in exceptions are aborted txns if(this.exceptions.length <= 0) { return; } @@ -75,4 +77,9 @@ 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; + } } diff --git common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidReadTxnList.java index 2f35917..4e57772 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,32 +31,27 @@ public class ValidReadTxnList implements ValidTxnList { protected long[] exceptions; + protected BitSet abortedBits; // BitSet for flagging aborted transactions. Bit is 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) { - if (exceptions.length == 0) { - this.exceptions = exceptions; - } else { - this.exceptions = exceptions.clone(); - Arrays.sort(this.exceptions); + public ValidReadTxnList(long[] exceptions, BitSet abortedBits, long highWatermark, long minOpenTxn) { + if (exceptions.length > 0) { this.minOpenTxn = minOpenTxn; - if(this.exceptions[0] <= 0) { - //should never happen of course - throw new IllegalArgumentException("Invalid txnid: " + this.exceptions[0] + " found"); - } } + this.exceptions = exceptions; + this.abortedBits = abortedBits; this.highWatermark = highWatermark; } @@ -118,12 +114,28 @@ public String writeToString() { buf.append(':'); buf.append(minOpenTxn); if (exceptions.length == 0) { - buf.append(':'); + buf.append(':'); // separator for open txns + buf.append(':'); // separator for aborted txns } else { - for(long except: exceptions) { - buf.append(':'); - buf.append(except); + StringBuilder open = new StringBuilder(); + StringBuilder abort = new StringBuilder(); + for (int i = 0; i < exceptions.length; i++) { + if (abortedBits.get(i)) { + if (abort.length() > 0) { + abort.append(','); + } + abort.append(exceptions[i]); + } else { + if (open.length() > 0) { + open.append(','); + } + open.append(exceptions[i]); + } } + buf.append(':'); + buf.append(open); + buf.append(':'); + buf.append(abort); } return buf.toString(); } @@ -133,13 +145,41 @@ public void readFromString(String src) { if (src == null || src.length() == 0) { highWatermark = Long.MAX_VALUE; exceptions = new long[0]; + abortedBits = new BitSet(); } else { String[] values = src.split(":"); highWatermark = Long.parseLong(values[0]); minOpenTxn = Long.parseLong(values[1]); - exceptions = new long[values.length - 2]; - for(int i = 2; i < values.length; ++i) { - exceptions[i-2] = Long.parseLong(values[i]); + String[] openTxns = new String[0]; + String[] abortedTxns = new String[0]; + if (values.length < 3) { + openTxns = new String[0]; + abortedTxns = new String[0]; + } else if (values.length == 3) { + if (!values[2].isEmpty()) { + openTxns = values[2].split(","); + } + } else { + if (!values[2].isEmpty()) { + openTxns = values[2].split(","); + } + if (!values[3].isEmpty()) { + abortedTxns = values[3].split(","); + } + } + exceptions = new long[openTxns.length + abortedTxns.length]; + int i = 0; + for (String open : openTxns) { + exceptions[i++] = Long.parseLong(open); + } + for (String abort : abortedTxns) { + exceptions[i++] = Long.parseLong(abort); + } + Arrays.sort(exceptions); + abortedBits = new BitSet(exceptions.length); + for (String abort : abortedTxns) { + int index = Arrays.binarySearch(exceptions, Long.parseLong(abort)); + abortedBits.set(index); } } } @@ -157,5 +197,40 @@ 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; + } + + int count = 0; // number of aborted txns found in exceptions + + // traverse the aborted txns list, starting at first aborted txn index + for (int i = abortedBits.nextSetBit(0); i >= 0; i = abortedBits.nextSetBit(i + 1)) { + long abortedTxnId = exceptions[i]; + if (abortedTxnId > maxTxnId) { // we've already gone beyond the specified range + break; + } + if (abortedTxnId >= minTxnId && abortedTxnId <= maxTxnId) { + count++; + } + } + + 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/ValidTxnList.java common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java index 5e1e4ee..d4ac02c 100644 --- common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java +++ common/src/java/org/apache/hadoop/hive/common/ValidTxnList.java @@ -71,7 +71,7 @@ /** * Populate this validTxnList from the string. It is assumed that the string - * was created via {@link #writeToString()}. + * was created via {@link #writeToString()} and the exceptions list is sorted. * @param src source string. */ public void readFromString(String src); @@ -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..00ee820 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,9 +35,9 @@ @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); + Assert.assertEquals("1:" + Long.MAX_VALUE + "::", str); ValidTxnList newList = new ValidReadTxnList(); newList.readFromString(str); Assert.assertTrue(newList.isTxnValid(1)); @@ -45,9 +46,9 @@ 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); + Assert.assertEquals("5:4:2,4:", str); ValidTxnList newList = new ValidReadTxnList(); newList.readFromString(str); Assert.assertTrue(newList.isTxnValid(1)); @@ -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); @@ -89,4 +90,20 @@ public void readWriteConfig() throws Exception { newConf.readFields(in); Assert.assertEquals(str, newConf.get(ValidTxnList.VALID_TXNS_KEY)); } + + @Test + public void testAbortedTxn() throws Exception { + long[] exceptions = {2L, 4L, 6L, 8L, 10L}; + BitSet bitSet = new BitSet(exceptions.length); + bitSet.set(0); // mark txn "2L" aborted + bitSet.set(3); // mark txn "8L" aborted + ValidTxnList txnList = new ValidReadTxnList(exceptions, bitSet, 11, 4L); + String str = txnList.writeToString(); + Assert.assertEquals("11:4:4,6,10:2,8", str); + Assert.assertTrue(txnList.isTxnAborted(2L)); + Assert.assertFalse(txnList.isTxnAborted(4L)); + Assert.assertFalse(txnList.isTxnAborted(6L)); + Assert.assertTrue(txnList.isTxnAborted(8L)); + Assert.assertFalse(txnList.isTxnAborted(10L)); + } } 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 f92db7c..e0c05bd 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 ff66836..ca6a007 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, // set changed to list 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 54d6438..9042cdb 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(); } @@ -5976,14 +5976,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->partNames.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->partNames.resize(_size912); + uint32_t _i916; + for (_i916 = 0; _i916 < _size912; ++_i916) { - xfer += iprot->readString(this->partNames[_i917]); + xfer += iprot->readString(this->partNames[_i916]); } xfer += iprot->readListEnd(); } @@ -6020,10 +6020,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter918; - for (_iter918 = this->partNames.begin(); _iter918 != this->partNames.end(); ++_iter918) + std::vector ::const_iterator _iter917; + for (_iter917 = this->partNames.begin(); _iter917 != this->partNames.end(); ++_iter917) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter917)); } xfer += oprot->writeListEnd(); } @@ -6055,10 +6055,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter919; - for (_iter919 = (*(this->partNames)).begin(); _iter919 != (*(this->partNames)).end(); ++_iter919) + std::vector ::const_iterator _iter918; + for (_iter918 = (*(this->partNames)).begin(); _iter918 != (*(this->partNames)).end(); ++_iter918) { - xfer += oprot->writeString((*_iter919)); + xfer += oprot->writeString((*_iter918)); } xfer += oprot->writeListEnd(); } @@ -6302,14 +6302,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size920; - ::apache::thrift::protocol::TType _etype923; - xfer += iprot->readListBegin(_etype923, _size920); - this->success.resize(_size920); - uint32_t _i924; - for (_i924 = 0; _i924 < _size920; ++_i924) + 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) { - xfer += iprot->readString(this->success[_i924]); + xfer += iprot->readString(this->success[_i923]); } xfer += iprot->readListEnd(); } @@ -6348,10 +6348,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 _iter925; - for (_iter925 = this->success.begin(); _iter925 != this->success.end(); ++_iter925) + std::vector ::const_iterator _iter924; + for (_iter924 = this->success.begin(); _iter924 != this->success.end(); ++_iter924) { - xfer += oprot->writeString((*_iter925)); + xfer += oprot->writeString((*_iter924)); } xfer += oprot->writeListEnd(); } @@ -6396,14 +6396,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size926; - ::apache::thrift::protocol::TType _etype929; - xfer += iprot->readListBegin(_etype929, _size926); - (*(this->success)).resize(_size926); - uint32_t _i930; - for (_i930 = 0; _i930 < _size926; ++_i930) + uint32_t _size925; + ::apache::thrift::protocol::TType _etype928; + xfer += iprot->readListBegin(_etype928, _size925); + (*(this->success)).resize(_size925); + uint32_t _i929; + for (_i929 = 0; _i929 < _size925; ++_i929) { - xfer += iprot->readString((*(this->success))[_i930]); + xfer += iprot->readString((*(this->success))[_i929]); } xfer += iprot->readListEnd(); } @@ -6573,14 +6573,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 _size931; - ::apache::thrift::protocol::TType _etype934; - xfer += iprot->readListBegin(_etype934, _size931); - this->success.resize(_size931); - uint32_t _i935; - for (_i935 = 0; _i935 < _size931; ++_i935) + 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) { - xfer += iprot->readString(this->success[_i935]); + xfer += iprot->readString(this->success[_i934]); } xfer += iprot->readListEnd(); } @@ -6619,10 +6619,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 _iter936; - for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) + std::vector ::const_iterator _iter935; + for (_iter935 = this->success.begin(); _iter935 != this->success.end(); ++_iter935) { - xfer += oprot->writeString((*_iter936)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -6667,14 +6667,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size937; - ::apache::thrift::protocol::TType _etype940; - xfer += iprot->readListBegin(_etype940, _size937); - (*(this->success)).resize(_size937); - uint32_t _i941; - for (_i941 = 0; _i941 < _size937; ++_i941) + uint32_t _size936; + ::apache::thrift::protocol::TType _etype939; + xfer += iprot->readListBegin(_etype939, _size936); + (*(this->success)).resize(_size936); + uint32_t _i940; + for (_i940 = 0; _i940 < _size936; ++_i940) { - xfer += iprot->readString((*(this->success))[_i941]); + xfer += iprot->readString((*(this->success))[_i940]); } xfer += iprot->readListEnd(); } @@ -6749,14 +6749,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 _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->tbl_types.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->tbl_types.resize(_size941); + uint32_t _i945; + for (_i945 = 0; _i945 < _size941; ++_i945) { - xfer += iprot->readString(this->tbl_types[_i946]); + xfer += iprot->readString(this->tbl_types[_i945]); } xfer += iprot->readListEnd(); } @@ -6793,10 +6793,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 _iter947; - for (_iter947 = this->tbl_types.begin(); _iter947 != this->tbl_types.end(); ++_iter947) + std::vector ::const_iterator _iter946; + for (_iter946 = this->tbl_types.begin(); _iter946 != this->tbl_types.end(); ++_iter946) { - xfer += oprot->writeString((*_iter947)); + xfer += oprot->writeString((*_iter946)); } xfer += oprot->writeListEnd(); } @@ -6828,10 +6828,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 _iter948; - for (_iter948 = (*(this->tbl_types)).begin(); _iter948 != (*(this->tbl_types)).end(); ++_iter948) + std::vector ::const_iterator _iter947; + for (_iter947 = (*(this->tbl_types)).begin(); _iter947 != (*(this->tbl_types)).end(); ++_iter947) { - xfer += oprot->writeString((*_iter948)); + xfer += oprot->writeString((*_iter947)); } xfer += oprot->writeListEnd(); } @@ -6872,14 +6872,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - this->success.resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + 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) { - xfer += this->success[_i953].read(iprot); + xfer += this->success[_i952].read(iprot); } xfer += iprot->readListEnd(); } @@ -6918,10 +6918,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 _iter954; - for (_iter954 = this->success.begin(); _iter954 != this->success.end(); ++_iter954) + std::vector ::const_iterator _iter953; + for (_iter953 = this->success.begin(); _iter953 != this->success.end(); ++_iter953) { - xfer += (*_iter954).write(oprot); + xfer += (*_iter953).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6966,14 +6966,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - (*(this->success)).resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + uint32_t _size954; + ::apache::thrift::protocol::TType _etype957; + xfer += iprot->readListBegin(_etype957, _size954); + (*(this->success)).resize(_size954); + uint32_t _i958; + for (_i958 = 0; _i958 < _size954; ++_i958) { - xfer += (*(this->success))[_i959].read(iprot); + xfer += (*(this->success))[_i958].read(iprot); } xfer += iprot->readListEnd(); } @@ -7111,14 +7111,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size960; - ::apache::thrift::protocol::TType _etype963; - xfer += iprot->readListBegin(_etype963, _size960); - this->success.resize(_size960); - uint32_t _i964; - for (_i964 = 0; _i964 < _size960; ++_i964) + 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) { - xfer += iprot->readString(this->success[_i964]); + xfer += iprot->readString(this->success[_i963]); } xfer += iprot->readListEnd(); } @@ -7157,10 +7157,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 _iter965; - for (_iter965 = this->success.begin(); _iter965 != this->success.end(); ++_iter965) + std::vector ::const_iterator _iter964; + for (_iter964 = this->success.begin(); _iter964 != this->success.end(); ++_iter964) { - xfer += oprot->writeString((*_iter965)); + xfer += oprot->writeString((*_iter964)); } xfer += oprot->writeListEnd(); } @@ -7205,14 +7205,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size966; - ::apache::thrift::protocol::TType _etype969; - xfer += iprot->readListBegin(_etype969, _size966); - (*(this->success)).resize(_size966); - uint32_t _i970; - for (_i970 = 0; _i970 < _size966; ++_i970) + uint32_t _size965; + ::apache::thrift::protocol::TType _etype968; + xfer += iprot->readListBegin(_etype968, _size965); + (*(this->success)).resize(_size965); + uint32_t _i969; + for (_i969 = 0; _i969 < _size965; ++_i969) { - xfer += iprot->readString((*(this->success))[_i970]); + xfer += iprot->readString((*(this->success))[_i969]); } xfer += iprot->readListEnd(); } @@ -7522,14 +7522,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 _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->tbl_names.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->tbl_names.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += iprot->readString(this->tbl_names[_i975]); + xfer += iprot->readString(this->tbl_names[_i974]); } xfer += iprot->readListEnd(); } @@ -7562,10 +7562,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 _iter976; - for (_iter976 = this->tbl_names.begin(); _iter976 != this->tbl_names.end(); ++_iter976) + std::vector ::const_iterator _iter975; + for (_iter975 = this->tbl_names.begin(); _iter975 != this->tbl_names.end(); ++_iter975) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -7593,10 +7593,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 _iter977; - for (_iter977 = (*(this->tbl_names)).begin(); _iter977 != (*(this->tbl_names)).end(); ++_iter977) + std::vector ::const_iterator _iter976; + for (_iter976 = (*(this->tbl_names)).begin(); _iter976 != (*(this->tbl_names)).end(); ++_iter976) { - xfer += oprot->writeString((*_iter977)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -7637,14 +7637,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 _size978; - ::apache::thrift::protocol::TType _etype981; - xfer += iprot->readListBegin(_etype981, _size978); - this->success.resize(_size978); - uint32_t _i982; - for (_i982 = 0; _i982 < _size978; ++_i982) + 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) { - xfer += this->success[_i982].read(iprot); + xfer += this->success[_i981].read(iprot); } xfer += iprot->readListEnd(); } @@ -7675,10 +7675,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 _iter983; - for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) + std::vector
::const_iterator _iter982; + for (_iter982 = this->success.begin(); _iter982 != this->success.end(); ++_iter982) { - xfer += (*_iter983).write(oprot); + xfer += (*_iter982).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7719,14 +7719,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 _size984; - ::apache::thrift::protocol::TType _etype987; - xfer += iprot->readListBegin(_etype987, _size984); - (*(this->success)).resize(_size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size983; + ::apache::thrift::protocol::TType _etype986; + xfer += iprot->readListBegin(_etype986, _size983); + (*(this->success)).resize(_size983); + uint32_t _i987; + for (_i987 = 0; _i987 < _size983; ++_i987) { - xfer += (*(this->success))[_i988].read(iprot); + xfer += (*(this->success))[_i987].read(iprot); } xfer += iprot->readListEnd(); } @@ -8362,14 +8362,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 _size989; - ::apache::thrift::protocol::TType _etype992; - xfer += iprot->readListBegin(_etype992, _size989); - this->success.resize(_size989); - uint32_t _i993; - for (_i993 = 0; _i993 < _size989; ++_i993) + 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) { - xfer += iprot->readString(this->success[_i993]); + xfer += iprot->readString(this->success[_i992]); } xfer += iprot->readListEnd(); } @@ -8424,10 +8424,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 _iter994; - for (_iter994 = this->success.begin(); _iter994 != this->success.end(); ++_iter994) + std::vector ::const_iterator _iter993; + for (_iter993 = this->success.begin(); _iter993 != this->success.end(); ++_iter993) { - xfer += oprot->writeString((*_iter994)); + xfer += oprot->writeString((*_iter993)); } xfer += oprot->writeListEnd(); } @@ -8480,14 +8480,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 _size995; - ::apache::thrift::protocol::TType _etype998; - xfer += iprot->readListBegin(_etype998, _size995); - (*(this->success)).resize(_size995); - uint32_t _i999; - for (_i999 = 0; _i999 < _size995; ++_i999) + uint32_t _size994; + ::apache::thrift::protocol::TType _etype997; + xfer += iprot->readListBegin(_etype997, _size994); + (*(this->success)).resize(_size994); + uint32_t _i998; + for (_i998 = 0; _i998 < _size994; ++_i998) { - xfer += iprot->readString((*(this->success))[_i999]); + xfer += iprot->readString((*(this->success))[_i998]); } xfer += iprot->readListEnd(); } @@ -9821,14 +9821,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco 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(); } @@ -9857,10 +9857,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 _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(); } @@ -9884,10 +9884,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 _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(); } @@ -10096,14 +10096,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 _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->new_parts.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->new_parts.resize(_size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - xfer += this->new_parts[_i1011].read(iprot); + xfer += this->new_parts[_i1010].read(iprot); } xfer += iprot->readListEnd(); } @@ -10132,10 +10132,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 _iter1012; - for (_iter1012 = this->new_parts.begin(); _iter1012 != this->new_parts.end(); ++_iter1012) + std::vector ::const_iterator _iter1011; + for (_iter1011 = this->new_parts.begin(); _iter1011 != this->new_parts.end(); ++_iter1011) { - xfer += (*_iter1012).write(oprot); + xfer += (*_iter1011).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10159,10 +10159,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 _iter1013; - for (_iter1013 = (*(this->new_parts)).begin(); _iter1013 != (*(this->new_parts)).end(); ++_iter1013) + std::vector ::const_iterator _iter1012; + for (_iter1012 = (*(this->new_parts)).begin(); _iter1012 != (*(this->new_parts)).end(); ++_iter1012) { - xfer += (*_iter1013).write(oprot); + xfer += (*_iter1012).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10387,14 +10387,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto 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(); } @@ -10431,10 +10431,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 _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(); } @@ -10466,10 +10466,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 _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(); } @@ -10941,14 +10941,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea 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(); } @@ -10993,10 +10993,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 _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(); } @@ -11032,10 +11032,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 _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(); } @@ -11838,14 +11838,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco 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(); } @@ -11890,10 +11890,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 _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(); } @@ -11929,10 +11929,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 _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(); } @@ -12141,14 +12141,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( 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(); } @@ -12201,10 +12201,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 _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(); } @@ -12244,10 +12244,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 _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(); } @@ -13253,14 +13253,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _etype1045; - xfer += iprot->readListBegin(_etype1045, _size1042); - this->part_vals.resize(_size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1041; + ::apache::thrift::protocol::TType _etype1044; + xfer += iprot->readListBegin(_etype1044, _size1041); + this->part_vals.resize(_size1041); + uint32_t _i1045; + for (_i1045 = 0; _i1045 < _size1041; ++_i1045) { - xfer += iprot->readString(this->part_vals[_i1046]); + xfer += iprot->readString(this->part_vals[_i1045]); } xfer += iprot->readListEnd(); } @@ -13297,10 +13297,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 _iter1047; - for (_iter1047 = this->part_vals.begin(); _iter1047 != this->part_vals.end(); ++_iter1047) + std::vector ::const_iterator _iter1046; + for (_iter1046 = this->part_vals.begin(); _iter1046 != this->part_vals.end(); ++_iter1046) { - xfer += oprot->writeString((*_iter1047)); + xfer += oprot->writeString((*_iter1046)); } xfer += oprot->writeListEnd(); } @@ -13332,10 +13332,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 _iter1048; - for (_iter1048 = (*(this->part_vals)).begin(); _iter1048 != (*(this->part_vals)).end(); ++_iter1048) + std::vector ::const_iterator _iter1047; + for (_iter1047 = (*(this->part_vals)).begin(); _iter1047 != (*(this->part_vals)).end(); ++_iter1047) { - xfer += oprot->writeString((*_iter1048)); + xfer += oprot->writeString((*_iter1047)); } xfer += oprot->writeListEnd(); } @@ -13524,17 +13524,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1049; - ::apache::thrift::protocol::TType _ktype1050; - ::apache::thrift::protocol::TType _vtype1051; - xfer += iprot->readMapBegin(_ktype1050, _vtype1051, _size1049); - uint32_t _i1053; - for (_i1053 = 0; _i1053 < _size1049; ++_i1053) + uint32_t _size1048; + ::apache::thrift::protocol::TType _ktype1049; + ::apache::thrift::protocol::TType _vtype1050; + xfer += iprot->readMapBegin(_ktype1049, _vtype1050, _size1048); + uint32_t _i1052; + for (_i1052 = 0; _i1052 < _size1048; ++_i1052) { - std::string _key1054; - xfer += iprot->readString(_key1054); - std::string& _val1055 = this->partitionSpecs[_key1054]; - xfer += iprot->readString(_val1055); + std::string _key1053; + xfer += iprot->readString(_key1053); + std::string& _val1054 = this->partitionSpecs[_key1053]; + xfer += iprot->readString(_val1054); } xfer += iprot->readMapEnd(); } @@ -13595,11 +13595,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 _iter1056; - for (_iter1056 = this->partitionSpecs.begin(); _iter1056 != this->partitionSpecs.end(); ++_iter1056) + std::map ::const_iterator _iter1055; + for (_iter1055 = this->partitionSpecs.begin(); _iter1055 != this->partitionSpecs.end(); ++_iter1055) { - xfer += oprot->writeString(_iter1056->first); - xfer += oprot->writeString(_iter1056->second); + xfer += oprot->writeString(_iter1055->first); + xfer += oprot->writeString(_iter1055->second); } xfer += oprot->writeMapEnd(); } @@ -13639,11 +13639,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 _iter1057; - for (_iter1057 = (*(this->partitionSpecs)).begin(); _iter1057 != (*(this->partitionSpecs)).end(); ++_iter1057) + std::map ::const_iterator _iter1056; + for (_iter1056 = (*(this->partitionSpecs)).begin(); _iter1056 != (*(this->partitionSpecs)).end(); ++_iter1056) { - xfer += oprot->writeString(_iter1057->first); - xfer += oprot->writeString(_iter1057->second); + xfer += oprot->writeString(_iter1056->first); + xfer += oprot->writeString(_iter1056->second); } xfer += oprot->writeMapEnd(); } @@ -13888,17 +13888,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1058; - ::apache::thrift::protocol::TType _ktype1059; - ::apache::thrift::protocol::TType _vtype1060; - xfer += iprot->readMapBegin(_ktype1059, _vtype1060, _size1058); - uint32_t _i1062; - for (_i1062 = 0; _i1062 < _size1058; ++_i1062) + uint32_t _size1057; + ::apache::thrift::protocol::TType _ktype1058; + ::apache::thrift::protocol::TType _vtype1059; + xfer += iprot->readMapBegin(_ktype1058, _vtype1059, _size1057); + uint32_t _i1061; + for (_i1061 = 0; _i1061 < _size1057; ++_i1061) { - std::string _key1063; - xfer += iprot->readString(_key1063); - std::string& _val1064 = this->partitionSpecs[_key1063]; - xfer += iprot->readString(_val1064); + std::string _key1062; + xfer += iprot->readString(_key1062); + std::string& _val1063 = this->partitionSpecs[_key1062]; + xfer += iprot->readString(_val1063); } xfer += iprot->readMapEnd(); } @@ -13959,11 +13959,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 _iter1065; - for (_iter1065 = this->partitionSpecs.begin(); _iter1065 != this->partitionSpecs.end(); ++_iter1065) + std::map ::const_iterator _iter1064; + for (_iter1064 = this->partitionSpecs.begin(); _iter1064 != this->partitionSpecs.end(); ++_iter1064) { - xfer += oprot->writeString(_iter1065->first); - xfer += oprot->writeString(_iter1065->second); + xfer += oprot->writeString(_iter1064->first); + xfer += oprot->writeString(_iter1064->second); } xfer += oprot->writeMapEnd(); } @@ -14003,11 +14003,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 _iter1066; - for (_iter1066 = (*(this->partitionSpecs)).begin(); _iter1066 != (*(this->partitionSpecs)).end(); ++_iter1066) + std::map ::const_iterator _iter1065; + for (_iter1065 = (*(this->partitionSpecs)).begin(); _iter1065 != (*(this->partitionSpecs)).end(); ++_iter1065) { - xfer += oprot->writeString(_iter1066->first); - xfer += oprot->writeString(_iter1066->second); + xfer += oprot->writeString(_iter1065->first); + xfer += oprot->writeString(_iter1065->second); } xfer += oprot->writeMapEnd(); } @@ -14064,14 +14064,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->success.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1066; + ::apache::thrift::protocol::TType _etype1069; + xfer += iprot->readListBegin(_etype1069, _size1066); + this->success.resize(_size1066); + uint32_t _i1070; + for (_i1070 = 0; _i1070 < _size1066; ++_i1070) { - xfer += this->success[_i1071].read(iprot); + xfer += this->success[_i1070].read(iprot); } xfer += iprot->readListEnd(); } @@ -14134,10 +14134,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 _iter1072; - for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) + std::vector ::const_iterator _iter1071; + for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) { - xfer += (*_iter1072).write(oprot); + xfer += (*_iter1071).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14194,14 +14194,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1073; - ::apache::thrift::protocol::TType _etype1076; - xfer += iprot->readListBegin(_etype1076, _size1073); - (*(this->success)).resize(_size1073); - uint32_t _i1077; - for (_i1077 = 0; _i1077 < _size1073; ++_i1077) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + (*(this->success)).resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += (*(this->success))[_i1077].read(iprot); + xfer += (*(this->success))[_i1076].read(iprot); } xfer += iprot->readListEnd(); } @@ -14300,14 +14300,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 _size1078; - ::apache::thrift::protocol::TType _etype1081; - xfer += iprot->readListBegin(_etype1081, _size1078); - this->part_vals.resize(_size1078); - uint32_t _i1082; - for (_i1082 = 0; _i1082 < _size1078; ++_i1082) + uint32_t _size1077; + ::apache::thrift::protocol::TType _etype1080; + xfer += iprot->readListBegin(_etype1080, _size1077); + this->part_vals.resize(_size1077); + uint32_t _i1081; + for (_i1081 = 0; _i1081 < _size1077; ++_i1081) { - xfer += iprot->readString(this->part_vals[_i1082]); + xfer += iprot->readString(this->part_vals[_i1081]); } xfer += iprot->readListEnd(); } @@ -14328,14 +14328,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 _size1083; - ::apache::thrift::protocol::TType _etype1086; - xfer += iprot->readListBegin(_etype1086, _size1083); - this->group_names.resize(_size1083); - uint32_t _i1087; - for (_i1087 = 0; _i1087 < _size1083; ++_i1087) + uint32_t _size1082; + ::apache::thrift::protocol::TType _etype1085; + xfer += iprot->readListBegin(_etype1085, _size1082); + this->group_names.resize(_size1082); + uint32_t _i1086; + for (_i1086 = 0; _i1086 < _size1082; ++_i1086) { - xfer += iprot->readString(this->group_names[_i1087]); + xfer += iprot->readString(this->group_names[_i1086]); } xfer += iprot->readListEnd(); } @@ -14372,10 +14372,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 _iter1088; - for (_iter1088 = this->part_vals.begin(); _iter1088 != this->part_vals.end(); ++_iter1088) + std::vector ::const_iterator _iter1087; + for (_iter1087 = this->part_vals.begin(); _iter1087 != this->part_vals.end(); ++_iter1087) { - xfer += oprot->writeString((*_iter1088)); + xfer += oprot->writeString((*_iter1087)); } xfer += oprot->writeListEnd(); } @@ -14388,10 +14388,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 _iter1089; - for (_iter1089 = this->group_names.begin(); _iter1089 != this->group_names.end(); ++_iter1089) + std::vector ::const_iterator _iter1088; + for (_iter1088 = this->group_names.begin(); _iter1088 != this->group_names.end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1089)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -14423,10 +14423,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 _iter1090; - for (_iter1090 = (*(this->part_vals)).begin(); _iter1090 != (*(this->part_vals)).end(); ++_iter1090) + std::vector ::const_iterator _iter1089; + for (_iter1089 = (*(this->part_vals)).begin(); _iter1089 != (*(this->part_vals)).end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1090)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -14439,10 +14439,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 _iter1091; - for (_iter1091 = (*(this->group_names)).begin(); _iter1091 != (*(this->group_names)).end(); ++_iter1091) + std::vector ::const_iterator _iter1090; + for (_iter1090 = (*(this->group_names)).begin(); _iter1090 != (*(this->group_names)).end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1091)); + xfer += oprot->writeString((*_iter1090)); } xfer += oprot->writeListEnd(); } @@ -15001,14 +15001,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1092; - ::apache::thrift::protocol::TType _etype1095; - xfer += iprot->readListBegin(_etype1095, _size1092); - this->success.resize(_size1092); - uint32_t _i1096; - for (_i1096 = 0; _i1096 < _size1092; ++_i1096) + 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) { - xfer += this->success[_i1096].read(iprot); + xfer += this->success[_i1095].read(iprot); } xfer += iprot->readListEnd(); } @@ -15055,10 +15055,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 _iter1097; - for (_iter1097 = this->success.begin(); _iter1097 != this->success.end(); ++_iter1097) + std::vector ::const_iterator _iter1096; + for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) { - xfer += (*_iter1097).write(oprot); + xfer += (*_iter1096).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15107,14 +15107,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1098; - ::apache::thrift::protocol::TType _etype1101; - xfer += iprot->readListBegin(_etype1101, _size1098); - (*(this->success)).resize(_size1098); - uint32_t _i1102; - for (_i1102 = 0; _i1102 < _size1098; ++_i1102) + uint32_t _size1097; + ::apache::thrift::protocol::TType _etype1100; + xfer += iprot->readListBegin(_etype1100, _size1097); + (*(this->success)).resize(_size1097); + uint32_t _i1101; + for (_i1101 = 0; _i1101 < _size1097; ++_i1101) { - xfer += (*(this->success))[_i1102].read(iprot); + xfer += (*(this->success))[_i1101].read(iprot); } xfer += iprot->readListEnd(); } @@ -15213,14 +15213,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 _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->group_names.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1102; + ::apache::thrift::protocol::TType _etype1105; + xfer += iprot->readListBegin(_etype1105, _size1102); + this->group_names.resize(_size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - xfer += iprot->readString(this->group_names[_i1107]); + xfer += iprot->readString(this->group_names[_i1106]); } xfer += iprot->readListEnd(); } @@ -15265,10 +15265,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 _iter1108; - for (_iter1108 = this->group_names.begin(); _iter1108 != this->group_names.end(); ++_iter1108) + std::vector ::const_iterator _iter1107; + for (_iter1107 = this->group_names.begin(); _iter1107 != this->group_names.end(); ++_iter1107) { - xfer += oprot->writeString((*_iter1108)); + xfer += oprot->writeString((*_iter1107)); } xfer += oprot->writeListEnd(); } @@ -15308,10 +15308,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 _iter1109; - for (_iter1109 = (*(this->group_names)).begin(); _iter1109 != (*(this->group_names)).end(); ++_iter1109) + std::vector ::const_iterator _iter1108; + for (_iter1108 = (*(this->group_names)).begin(); _iter1108 != (*(this->group_names)).end(); ++_iter1108) { - xfer += oprot->writeString((*_iter1109)); + xfer += oprot->writeString((*_iter1108)); } xfer += oprot->writeListEnd(); } @@ -15352,14 +15352,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1110; - ::apache::thrift::protocol::TType _etype1113; - xfer += iprot->readListBegin(_etype1113, _size1110); - this->success.resize(_size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1109; + ::apache::thrift::protocol::TType _etype1112; + xfer += iprot->readListBegin(_etype1112, _size1109); + this->success.resize(_size1109); + uint32_t _i1113; + for (_i1113 = 0; _i1113 < _size1109; ++_i1113) { - xfer += this->success[_i1114].read(iprot); + xfer += this->success[_i1113].read(iprot); } xfer += iprot->readListEnd(); } @@ -15406,10 +15406,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 _iter1115; - for (_iter1115 = this->success.begin(); _iter1115 != this->success.end(); ++_iter1115) + std::vector ::const_iterator _iter1114; + for (_iter1114 = this->success.begin(); _iter1114 != this->success.end(); ++_iter1114) { - xfer += (*_iter1115).write(oprot); + xfer += (*_iter1114).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15458,14 +15458,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1116; - ::apache::thrift::protocol::TType _etype1119; - xfer += iprot->readListBegin(_etype1119, _size1116); - (*(this->success)).resize(_size1116); - uint32_t _i1120; - for (_i1120 = 0; _i1120 < _size1116; ++_i1120) + uint32_t _size1115; + ::apache::thrift::protocol::TType _etype1118; + xfer += iprot->readListBegin(_etype1118, _size1115); + (*(this->success)).resize(_size1115); + uint32_t _i1119; + for (_i1119 = 0; _i1119 < _size1115; ++_i1119) { - xfer += (*(this->success))[_i1120].read(iprot); + xfer += (*(this->success))[_i1119].read(iprot); } xfer += iprot->readListEnd(); } @@ -15643,14 +15643,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1121; - ::apache::thrift::protocol::TType _etype1124; - xfer += iprot->readListBegin(_etype1124, _size1121); - this->success.resize(_size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + 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) { - xfer += this->success[_i1125].read(iprot); + xfer += this->success[_i1124].read(iprot); } xfer += iprot->readListEnd(); } @@ -15697,10 +15697,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 _iter1126; - for (_iter1126 = this->success.begin(); _iter1126 != this->success.end(); ++_iter1126) + std::vector ::const_iterator _iter1125; + for (_iter1125 = this->success.begin(); _iter1125 != this->success.end(); ++_iter1125) { - xfer += (*_iter1126).write(oprot); + xfer += (*_iter1125).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15749,14 +15749,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1127; - ::apache::thrift::protocol::TType _etype1130; - xfer += iprot->readListBegin(_etype1130, _size1127); - (*(this->success)).resize(_size1127); - uint32_t _i1131; - for (_i1131 = 0; _i1131 < _size1127; ++_i1131) + uint32_t _size1126; + ::apache::thrift::protocol::TType _etype1129; + xfer += iprot->readListBegin(_etype1129, _size1126); + (*(this->success)).resize(_size1126); + uint32_t _i1130; + for (_i1130 = 0; _i1130 < _size1126; ++_i1130) { - xfer += (*(this->success))[_i1131].read(iprot); + xfer += (*(this->success))[_i1130].read(iprot); } xfer += iprot->readListEnd(); } @@ -15934,14 +15934,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1132; - ::apache::thrift::protocol::TType _etype1135; - xfer += iprot->readListBegin(_etype1135, _size1132); - this->success.resize(_size1132); - uint32_t _i1136; - for (_i1136 = 0; _i1136 < _size1132; ++_i1136) + 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) { - xfer += iprot->readString(this->success[_i1136]); + xfer += iprot->readString(this->success[_i1135]); } xfer += iprot->readListEnd(); } @@ -15980,10 +15980,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 _iter1137; - for (_iter1137 = this->success.begin(); _iter1137 != this->success.end(); ++_iter1137) + std::vector ::const_iterator _iter1136; + for (_iter1136 = this->success.begin(); _iter1136 != this->success.end(); ++_iter1136) { - xfer += oprot->writeString((*_iter1137)); + xfer += oprot->writeString((*_iter1136)); } xfer += oprot->writeListEnd(); } @@ -16028,14 +16028,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1138; - ::apache::thrift::protocol::TType _etype1141; - xfer += iprot->readListBegin(_etype1141, _size1138); - (*(this->success)).resize(_size1138); - uint32_t _i1142; - for (_i1142 = 0; _i1142 < _size1138; ++_i1142) + uint32_t _size1137; + ::apache::thrift::protocol::TType _etype1140; + xfer += iprot->readListBegin(_etype1140, _size1137); + (*(this->success)).resize(_size1137); + uint32_t _i1141; + for (_i1141 = 0; _i1141 < _size1137; ++_i1141) { - xfer += iprot->readString((*(this->success))[_i1142]); + xfer += iprot->readString((*(this->success))[_i1141]); } xfer += iprot->readListEnd(); } @@ -16110,14 +16110,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 _size1143; - ::apache::thrift::protocol::TType _etype1146; - xfer += iprot->readListBegin(_etype1146, _size1143); - this->part_vals.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->part_vals.resize(_size1142); + uint32_t _i1146; + for (_i1146 = 0; _i1146 < _size1142; ++_i1146) { - xfer += iprot->readString(this->part_vals[_i1147]); + xfer += iprot->readString(this->part_vals[_i1146]); } xfer += iprot->readListEnd(); } @@ -16162,10 +16162,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 _iter1148; - for (_iter1148 = this->part_vals.begin(); _iter1148 != this->part_vals.end(); ++_iter1148) + std::vector ::const_iterator _iter1147; + for (_iter1147 = this->part_vals.begin(); _iter1147 != this->part_vals.end(); ++_iter1147) { - xfer += oprot->writeString((*_iter1148)); + xfer += oprot->writeString((*_iter1147)); } xfer += oprot->writeListEnd(); } @@ -16201,10 +16201,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 _iter1149; - for (_iter1149 = (*(this->part_vals)).begin(); _iter1149 != (*(this->part_vals)).end(); ++_iter1149) + std::vector ::const_iterator _iter1148; + for (_iter1148 = (*(this->part_vals)).begin(); _iter1148 != (*(this->part_vals)).end(); ++_iter1148) { - xfer += oprot->writeString((*_iter1149)); + xfer += oprot->writeString((*_iter1148)); } xfer += oprot->writeListEnd(); } @@ -16249,14 +16249,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1150; - ::apache::thrift::protocol::TType _etype1153; - xfer += iprot->readListBegin(_etype1153, _size1150); - this->success.resize(_size1150); - uint32_t _i1154; - for (_i1154 = 0; _i1154 < _size1150; ++_i1154) + uint32_t _size1149; + ::apache::thrift::protocol::TType _etype1152; + xfer += iprot->readListBegin(_etype1152, _size1149); + this->success.resize(_size1149); + uint32_t _i1153; + for (_i1153 = 0; _i1153 < _size1149; ++_i1153) { - xfer += this->success[_i1154].read(iprot); + xfer += this->success[_i1153].read(iprot); } xfer += iprot->readListEnd(); } @@ -16303,10 +16303,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 _iter1155; - for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) + std::vector ::const_iterator _iter1154; + for (_iter1154 = this->success.begin(); _iter1154 != this->success.end(); ++_iter1154) { - xfer += (*_iter1155).write(oprot); + xfer += (*_iter1154).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16355,14 +16355,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1156; - ::apache::thrift::protocol::TType _etype1159; - xfer += iprot->readListBegin(_etype1159, _size1156); - (*(this->success)).resize(_size1156); - uint32_t _i1160; - for (_i1160 = 0; _i1160 < _size1156; ++_i1160) + uint32_t _size1155; + ::apache::thrift::protocol::TType _etype1158; + xfer += iprot->readListBegin(_etype1158, _size1155); + (*(this->success)).resize(_size1155); + uint32_t _i1159; + for (_i1159 = 0; _i1159 < _size1155; ++_i1159) { - xfer += (*(this->success))[_i1160].read(iprot); + xfer += (*(this->success))[_i1159].read(iprot); } xfer += iprot->readListEnd(); } @@ -16445,14 +16445,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 _size1161; - ::apache::thrift::protocol::TType _etype1164; - xfer += iprot->readListBegin(_etype1164, _size1161); - this->part_vals.resize(_size1161); - uint32_t _i1165; - for (_i1165 = 0; _i1165 < _size1161; ++_i1165) + uint32_t _size1160; + ::apache::thrift::protocol::TType _etype1163; + xfer += iprot->readListBegin(_etype1163, _size1160); + this->part_vals.resize(_size1160); + uint32_t _i1164; + for (_i1164 = 0; _i1164 < _size1160; ++_i1164) { - xfer += iprot->readString(this->part_vals[_i1165]); + xfer += iprot->readString(this->part_vals[_i1164]); } xfer += iprot->readListEnd(); } @@ -16481,14 +16481,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 _size1166; - ::apache::thrift::protocol::TType _etype1169; - xfer += iprot->readListBegin(_etype1169, _size1166); - this->group_names.resize(_size1166); - uint32_t _i1170; - for (_i1170 = 0; _i1170 < _size1166; ++_i1170) + uint32_t _size1165; + ::apache::thrift::protocol::TType _etype1168; + xfer += iprot->readListBegin(_etype1168, _size1165); + this->group_names.resize(_size1165); + uint32_t _i1169; + for (_i1169 = 0; _i1169 < _size1165; ++_i1169) { - xfer += iprot->readString(this->group_names[_i1170]); + xfer += iprot->readString(this->group_names[_i1169]); } xfer += iprot->readListEnd(); } @@ -16525,10 +16525,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 _iter1171; - for (_iter1171 = this->part_vals.begin(); _iter1171 != this->part_vals.end(); ++_iter1171) + std::vector ::const_iterator _iter1170; + for (_iter1170 = this->part_vals.begin(); _iter1170 != this->part_vals.end(); ++_iter1170) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1170)); } xfer += oprot->writeListEnd(); } @@ -16545,10 +16545,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 _iter1172; - for (_iter1172 = this->group_names.begin(); _iter1172 != this->group_names.end(); ++_iter1172) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->group_names.begin(); _iter1171 != this->group_names.end(); ++_iter1171) { - xfer += oprot->writeString((*_iter1172)); + xfer += oprot->writeString((*_iter1171)); } xfer += oprot->writeListEnd(); } @@ -16580,10 +16580,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 _iter1173; - for (_iter1173 = (*(this->part_vals)).begin(); _iter1173 != (*(this->part_vals)).end(); ++_iter1173) + std::vector ::const_iterator _iter1172; + for (_iter1172 = (*(this->part_vals)).begin(); _iter1172 != (*(this->part_vals)).end(); ++_iter1172) { - xfer += oprot->writeString((*_iter1173)); + xfer += oprot->writeString((*_iter1172)); } xfer += oprot->writeListEnd(); } @@ -16600,10 +16600,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 _iter1174; - for (_iter1174 = (*(this->group_names)).begin(); _iter1174 != (*(this->group_names)).end(); ++_iter1174) + std::vector ::const_iterator _iter1173; + for (_iter1173 = (*(this->group_names)).begin(); _iter1173 != (*(this->group_names)).end(); ++_iter1173) { - xfer += oprot->writeString((*_iter1174)); + xfer += oprot->writeString((*_iter1173)); } xfer += oprot->writeListEnd(); } @@ -16644,14 +16644,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1175; - ::apache::thrift::protocol::TType _etype1178; - xfer += iprot->readListBegin(_etype1178, _size1175); - this->success.resize(_size1175); - uint32_t _i1179; - for (_i1179 = 0; _i1179 < _size1175; ++_i1179) + 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) { - xfer += this->success[_i1179].read(iprot); + xfer += this->success[_i1178].read(iprot); } xfer += iprot->readListEnd(); } @@ -16698,10 +16698,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 _iter1180; - for (_iter1180 = this->success.begin(); _iter1180 != this->success.end(); ++_iter1180) + std::vector ::const_iterator _iter1179; + for (_iter1179 = this->success.begin(); _iter1179 != this->success.end(); ++_iter1179) { - xfer += (*_iter1180).write(oprot); + xfer += (*_iter1179).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16750,14 +16750,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1181; - ::apache::thrift::protocol::TType _etype1184; - xfer += iprot->readListBegin(_etype1184, _size1181); - (*(this->success)).resize(_size1181); - uint32_t _i1185; - for (_i1185 = 0; _i1185 < _size1181; ++_i1185) + uint32_t _size1180; + ::apache::thrift::protocol::TType _etype1183; + xfer += iprot->readListBegin(_etype1183, _size1180); + (*(this->success)).resize(_size1180); + uint32_t _i1184; + for (_i1184 = 0; _i1184 < _size1180; ++_i1184) { - xfer += (*(this->success))[_i1185].read(iprot); + xfer += (*(this->success))[_i1184].read(iprot); } xfer += iprot->readListEnd(); } @@ -16840,14 +16840,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 _size1186; - ::apache::thrift::protocol::TType _etype1189; - xfer += iprot->readListBegin(_etype1189, _size1186); - this->part_vals.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->part_vals.resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += iprot->readString(this->part_vals[_i1190]); + xfer += iprot->readString(this->part_vals[_i1189]); } xfer += iprot->readListEnd(); } @@ -16892,10 +16892,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 _iter1191; - for (_iter1191 = this->part_vals.begin(); _iter1191 != this->part_vals.end(); ++_iter1191) + std::vector ::const_iterator _iter1190; + for (_iter1190 = this->part_vals.begin(); _iter1190 != this->part_vals.end(); ++_iter1190) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1190)); } xfer += oprot->writeListEnd(); } @@ -16931,10 +16931,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 _iter1192; - for (_iter1192 = (*(this->part_vals)).begin(); _iter1192 != (*(this->part_vals)).end(); ++_iter1192) + std::vector ::const_iterator _iter1191; + for (_iter1191 = (*(this->part_vals)).begin(); _iter1191 != (*(this->part_vals)).end(); ++_iter1191) { - xfer += oprot->writeString((*_iter1192)); + xfer += oprot->writeString((*_iter1191)); } xfer += oprot->writeListEnd(); } @@ -16979,14 +16979,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1193; - ::apache::thrift::protocol::TType _etype1196; - xfer += iprot->readListBegin(_etype1196, _size1193); - this->success.resize(_size1193); - uint32_t _i1197; - for (_i1197 = 0; _i1197 < _size1193; ++_i1197) + 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) { - xfer += iprot->readString(this->success[_i1197]); + xfer += iprot->readString(this->success[_i1196]); } xfer += iprot->readListEnd(); } @@ -17033,10 +17033,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 _iter1198; - for (_iter1198 = this->success.begin(); _iter1198 != this->success.end(); ++_iter1198) + std::vector ::const_iterator _iter1197; + for (_iter1197 = this->success.begin(); _iter1197 != this->success.end(); ++_iter1197) { - xfer += oprot->writeString((*_iter1198)); + xfer += oprot->writeString((*_iter1197)); } xfer += oprot->writeListEnd(); } @@ -17085,14 +17085,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1199; - ::apache::thrift::protocol::TType _etype1202; - xfer += iprot->readListBegin(_etype1202, _size1199); - (*(this->success)).resize(_size1199); - uint32_t _i1203; - for (_i1203 = 0; _i1203 < _size1199; ++_i1203) + uint32_t _size1198; + ::apache::thrift::protocol::TType _etype1201; + xfer += iprot->readListBegin(_etype1201, _size1198); + (*(this->success)).resize(_size1198); + uint32_t _i1202; + for (_i1202 = 0; _i1202 < _size1198; ++_i1202) { - xfer += iprot->readString((*(this->success))[_i1203]); + xfer += iprot->readString((*(this->success))[_i1202]); } xfer += iprot->readListEnd(); } @@ -17286,14 +17286,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1204; - ::apache::thrift::protocol::TType _etype1207; - xfer += iprot->readListBegin(_etype1207, _size1204); - this->success.resize(_size1204); - uint32_t _i1208; - for (_i1208 = 0; _i1208 < _size1204; ++_i1208) + 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) { - xfer += this->success[_i1208].read(iprot); + xfer += this->success[_i1207].read(iprot); } xfer += iprot->readListEnd(); } @@ -17340,10 +17340,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 _iter1209; - for (_iter1209 = this->success.begin(); _iter1209 != this->success.end(); ++_iter1209) + std::vector ::const_iterator _iter1208; + for (_iter1208 = this->success.begin(); _iter1208 != this->success.end(); ++_iter1208) { - xfer += (*_iter1209).write(oprot); + xfer += (*_iter1208).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17392,14 +17392,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1210; - ::apache::thrift::protocol::TType _etype1213; - xfer += iprot->readListBegin(_etype1213, _size1210); - (*(this->success)).resize(_size1210); - uint32_t _i1214; - for (_i1214 = 0; _i1214 < _size1210; ++_i1214) + uint32_t _size1209; + ::apache::thrift::protocol::TType _etype1212; + xfer += iprot->readListBegin(_etype1212, _size1209); + (*(this->success)).resize(_size1209); + uint32_t _i1213; + for (_i1213 = 0; _i1213 < _size1209; ++_i1213) { - xfer += (*(this->success))[_i1214].read(iprot); + xfer += (*(this->success))[_i1213].read(iprot); } xfer += iprot->readListEnd(); } @@ -17593,14 +17593,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 _size1215; - ::apache::thrift::protocol::TType _etype1218; - xfer += iprot->readListBegin(_etype1218, _size1215); - this->success.resize(_size1215); - uint32_t _i1219; - for (_i1219 = 0; _i1219 < _size1215; ++_i1219) + 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) { - xfer += this->success[_i1219].read(iprot); + xfer += this->success[_i1218].read(iprot); } xfer += iprot->readListEnd(); } @@ -17647,10 +17647,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 _iter1220; - for (_iter1220 = this->success.begin(); _iter1220 != this->success.end(); ++_iter1220) + std::vector ::const_iterator _iter1219; + for (_iter1219 = this->success.begin(); _iter1219 != this->success.end(); ++_iter1219) { - xfer += (*_iter1220).write(oprot); + xfer += (*_iter1219).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17699,14 +17699,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 _size1221; - ::apache::thrift::protocol::TType _etype1224; - xfer += iprot->readListBegin(_etype1224, _size1221); - (*(this->success)).resize(_size1221); - uint32_t _i1225; - for (_i1225 = 0; _i1225 < _size1221; ++_i1225) + uint32_t _size1220; + ::apache::thrift::protocol::TType _etype1223; + xfer += iprot->readListBegin(_etype1223, _size1220); + (*(this->success)).resize(_size1220); + uint32_t _i1224; + for (_i1224 = 0; _i1224 < _size1220; ++_i1224) { - xfer += (*(this->success))[_i1225].read(iprot); + xfer += (*(this->success))[_i1224].read(iprot); } xfer += iprot->readListEnd(); } @@ -18275,14 +18275,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1226; - ::apache::thrift::protocol::TType _etype1229; - xfer += iprot->readListBegin(_etype1229, _size1226); - this->names.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->names.resize(_size1225); + uint32_t _i1229; + for (_i1229 = 0; _i1229 < _size1225; ++_i1229) { - xfer += iprot->readString(this->names[_i1230]); + xfer += iprot->readString(this->names[_i1229]); } xfer += iprot->readListEnd(); } @@ -18319,10 +18319,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 _iter1231; - for (_iter1231 = this->names.begin(); _iter1231 != this->names.end(); ++_iter1231) + std::vector ::const_iterator _iter1230; + for (_iter1230 = this->names.begin(); _iter1230 != this->names.end(); ++_iter1230) { - xfer += oprot->writeString((*_iter1231)); + xfer += oprot->writeString((*_iter1230)); } xfer += oprot->writeListEnd(); } @@ -18354,10 +18354,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 _iter1232; - for (_iter1232 = (*(this->names)).begin(); _iter1232 != (*(this->names)).end(); ++_iter1232) + std::vector ::const_iterator _iter1231; + for (_iter1231 = (*(this->names)).begin(); _iter1231 != (*(this->names)).end(); ++_iter1231) { - xfer += oprot->writeString((*_iter1232)); + xfer += oprot->writeString((*_iter1231)); } xfer += oprot->writeListEnd(); } @@ -18398,14 +18398,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1233; - ::apache::thrift::protocol::TType _etype1236; - xfer += iprot->readListBegin(_etype1236, _size1233); - this->success.resize(_size1233); - uint32_t _i1237; - for (_i1237 = 0; _i1237 < _size1233; ++_i1237) + 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) { - xfer += this->success[_i1237].read(iprot); + xfer += this->success[_i1236].read(iprot); } xfer += iprot->readListEnd(); } @@ -18452,10 +18452,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 _iter1238; - for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) + std::vector ::const_iterator _iter1237; + for (_iter1237 = this->success.begin(); _iter1237 != this->success.end(); ++_iter1237) { - xfer += (*_iter1238).write(oprot); + xfer += (*_iter1237).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18504,14 +18504,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1239; - ::apache::thrift::protocol::TType _etype1242; - xfer += iprot->readListBegin(_etype1242, _size1239); - (*(this->success)).resize(_size1239); - uint32_t _i1243; - for (_i1243 = 0; _i1243 < _size1239; ++_i1243) + uint32_t _size1238; + ::apache::thrift::protocol::TType _etype1241; + xfer += iprot->readListBegin(_etype1241, _size1238); + (*(this->success)).resize(_size1238); + uint32_t _i1242; + for (_i1242 = 0; _i1242 < _size1238; ++_i1242) { - xfer += (*(this->success))[_i1243].read(iprot); + xfer += (*(this->success))[_i1242].read(iprot); } xfer += iprot->readListEnd(); } @@ -18833,14 +18833,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto 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(); } @@ -18877,10 +18877,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 _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(); } @@ -18912,10 +18912,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 _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(); } @@ -19100,14 +19100,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - this->new_parts.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->new_parts.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += this->new_parts[_i1255].read(iprot); + xfer += this->new_parts[_i1254].read(iprot); } xfer += iprot->readListEnd(); } @@ -19152,10 +19152,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 _iter1256; - for (_iter1256 = this->new_parts.begin(); _iter1256 != this->new_parts.end(); ++_iter1256) + std::vector ::const_iterator _iter1255; + for (_iter1255 = this->new_parts.begin(); _iter1255 != this->new_parts.end(); ++_iter1255) { - xfer += (*_iter1256).write(oprot); + xfer += (*_iter1255).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19191,10 +19191,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 _iter1257; - for (_iter1257 = (*(this->new_parts)).begin(); _iter1257 != (*(this->new_parts)).end(); ++_iter1257) + std::vector ::const_iterator _iter1256; + for (_iter1256 = (*(this->new_parts)).begin(); _iter1256 != (*(this->new_parts)).end(); ++_iter1256) { - xfer += (*_iter1257).write(oprot); + xfer += (*_iter1256).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19638,14 +19638,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto 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(); } @@ -19690,10 +19690,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 _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(); } @@ -19729,10 +19729,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 _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(); } @@ -19905,14 +19905,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 _size1265; - ::apache::thrift::protocol::TType _etype1268; - xfer += iprot->readListBegin(_etype1268, _size1265); - this->part_vals.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->part_vals.resize(_size1264); + uint32_t _i1268; + for (_i1268 = 0; _i1268 < _size1264; ++_i1268) { - xfer += iprot->readString(this->part_vals[_i1269]); + xfer += iprot->readString(this->part_vals[_i1268]); } xfer += iprot->readListEnd(); } @@ -19949,10 +19949,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 _iter1270; - for (_iter1270 = this->part_vals.begin(); _iter1270 != this->part_vals.end(); ++_iter1270) + std::vector ::const_iterator _iter1269; + for (_iter1269 = this->part_vals.begin(); _iter1269 != this->part_vals.end(); ++_iter1269) { - xfer += oprot->writeString((*_iter1270)); + xfer += oprot->writeString((*_iter1269)); } xfer += oprot->writeListEnd(); } @@ -19980,10 +19980,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 _iter1271; - for (_iter1271 = (*(this->part_vals)).begin(); _iter1271 != (*(this->part_vals)).end(); ++_iter1271) + std::vector ::const_iterator _iter1270; + for (_iter1270 = (*(this->part_vals)).begin(); _iter1270 != (*(this->part_vals)).end(); ++_iter1270) { - xfer += oprot->writeString((*_iter1271)); + xfer += oprot->writeString((*_iter1270)); } xfer += oprot->writeListEnd(); } @@ -20458,14 +20458,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1272; - ::apache::thrift::protocol::TType _etype1275; - xfer += iprot->readListBegin(_etype1275, _size1272); - this->success.resize(_size1272); - uint32_t _i1276; - for (_i1276 = 0; _i1276 < _size1272; ++_i1276) + 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) { - xfer += iprot->readString(this->success[_i1276]); + xfer += iprot->readString(this->success[_i1275]); } xfer += iprot->readListEnd(); } @@ -20504,10 +20504,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 _iter1277; - for (_iter1277 = this->success.begin(); _iter1277 != this->success.end(); ++_iter1277) + std::vector ::const_iterator _iter1276; + for (_iter1276 = this->success.begin(); _iter1276 != this->success.end(); ++_iter1276) { - xfer += oprot->writeString((*_iter1277)); + xfer += oprot->writeString((*_iter1276)); } xfer += oprot->writeListEnd(); } @@ -20552,14 +20552,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1278; - ::apache::thrift::protocol::TType _etype1281; - xfer += iprot->readListBegin(_etype1281, _size1278); - (*(this->success)).resize(_size1278); - uint32_t _i1282; - for (_i1282 = 0; _i1282 < _size1278; ++_i1282) + uint32_t _size1277; + ::apache::thrift::protocol::TType _etype1280; + xfer += iprot->readListBegin(_etype1280, _size1277); + (*(this->success)).resize(_size1277); + uint32_t _i1281; + for (_i1281 = 0; _i1281 < _size1277; ++_i1281) { - xfer += iprot->readString((*(this->success))[_i1282]); + xfer += iprot->readString((*(this->success))[_i1281]); } xfer += iprot->readListEnd(); } @@ -20697,17 +20697,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - 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) + uint32_t _size1282; + ::apache::thrift::protocol::TType _ktype1283; + ::apache::thrift::protocol::TType _vtype1284; + xfer += iprot->readMapBegin(_ktype1283, _vtype1284, _size1282); + uint32_t _i1286; + for (_i1286 = 0; _i1286 < _size1282; ++_i1286) { - std::string _key1288; - xfer += iprot->readString(_key1288); - std::string& _val1289 = this->success[_key1288]; - xfer += iprot->readString(_val1289); + std::string _key1287; + xfer += iprot->readString(_key1287); + std::string& _val1288 = this->success[_key1287]; + xfer += iprot->readString(_val1288); } xfer += iprot->readMapEnd(); } @@ -20746,11 +20746,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 _iter1290; - for (_iter1290 = this->success.begin(); _iter1290 != this->success.end(); ++_iter1290) + std::map ::const_iterator _iter1289; + for (_iter1289 = this->success.begin(); _iter1289 != this->success.end(); ++_iter1289) { - xfer += oprot->writeString(_iter1290->first); - xfer += oprot->writeString(_iter1290->second); + xfer += oprot->writeString(_iter1289->first); + xfer += oprot->writeString(_iter1289->second); } xfer += oprot->writeMapEnd(); } @@ -20795,17 +20795,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).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->success))[_key1296]; - xfer += iprot->readString(_val1297); + std::string _key1295; + xfer += iprot->readString(_key1295); + std::string& _val1296 = (*(this->success))[_key1295]; + xfer += iprot->readString(_val1296); } xfer += iprot->readMapEnd(); } @@ -20880,17 +20880,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1298; - ::apache::thrift::protocol::TType _ktype1299; - ::apache::thrift::protocol::TType _vtype1300; - xfer += iprot->readMapBegin(_ktype1299, _vtype1300, _size1298); - uint32_t _i1302; - for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + uint32_t _size1297; + ::apache::thrift::protocol::TType _ktype1298; + ::apache::thrift::protocol::TType _vtype1299; + xfer += iprot->readMapBegin(_ktype1298, _vtype1299, _size1297); + uint32_t _i1301; + for (_i1301 = 0; _i1301 < _size1297; ++_i1301) { - std::string _key1303; - xfer += iprot->readString(_key1303); - std::string& _val1304 = this->part_vals[_key1303]; - xfer += iprot->readString(_val1304); + std::string _key1302; + xfer += iprot->readString(_key1302); + std::string& _val1303 = this->part_vals[_key1302]; + xfer += iprot->readString(_val1303); } xfer += iprot->readMapEnd(); } @@ -20901,9 +20901,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1305; - xfer += iprot->readI32(ecast1305); - this->eventType = (PartitionEventType::type)ecast1305; + int32_t ecast1304; + xfer += iprot->readI32(ecast1304); + this->eventType = (PartitionEventType::type)ecast1304; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20937,11 +20937,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 _iter1306; - for (_iter1306 = this->part_vals.begin(); _iter1306 != this->part_vals.end(); ++_iter1306) + std::map ::const_iterator _iter1305; + for (_iter1305 = this->part_vals.begin(); _iter1305 != this->part_vals.end(); ++_iter1305) { - xfer += oprot->writeString(_iter1306->first); - xfer += oprot->writeString(_iter1306->second); + xfer += oprot->writeString(_iter1305->first); + xfer += oprot->writeString(_iter1305->second); } xfer += oprot->writeMapEnd(); } @@ -20977,11 +20977,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 _iter1307; - for (_iter1307 = (*(this->part_vals)).begin(); _iter1307 != (*(this->part_vals)).end(); ++_iter1307) + std::map ::const_iterator _iter1306; + for (_iter1306 = (*(this->part_vals)).begin(); _iter1306 != (*(this->part_vals)).end(); ++_iter1306) { - xfer += oprot->writeString(_iter1307->first); - xfer += oprot->writeString(_iter1307->second); + xfer += oprot->writeString(_iter1306->first); + xfer += oprot->writeString(_iter1306->second); } xfer += oprot->writeMapEnd(); } @@ -21250,17 +21250,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1308; - ::apache::thrift::protocol::TType _ktype1309; - ::apache::thrift::protocol::TType _vtype1310; - xfer += iprot->readMapBegin(_ktype1309, _vtype1310, _size1308); - uint32_t _i1312; - for (_i1312 = 0; _i1312 < _size1308; ++_i1312) + uint32_t _size1307; + ::apache::thrift::protocol::TType _ktype1308; + ::apache::thrift::protocol::TType _vtype1309; + xfer += iprot->readMapBegin(_ktype1308, _vtype1309, _size1307); + uint32_t _i1311; + for (_i1311 = 0; _i1311 < _size1307; ++_i1311) { - std::string _key1313; - xfer += iprot->readString(_key1313); - std::string& _val1314 = this->part_vals[_key1313]; - xfer += iprot->readString(_val1314); + std::string _key1312; + xfer += iprot->readString(_key1312); + std::string& _val1313 = this->part_vals[_key1312]; + xfer += iprot->readString(_val1313); } xfer += iprot->readMapEnd(); } @@ -21271,9 +21271,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1315; - xfer += iprot->readI32(ecast1315); - this->eventType = (PartitionEventType::type)ecast1315; + int32_t ecast1314; + xfer += iprot->readI32(ecast1314); + this->eventType = (PartitionEventType::type)ecast1314; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21307,11 +21307,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 _iter1316; - for (_iter1316 = this->part_vals.begin(); _iter1316 != this->part_vals.end(); ++_iter1316) + std::map ::const_iterator _iter1315; + for (_iter1315 = this->part_vals.begin(); _iter1315 != this->part_vals.end(); ++_iter1315) { - xfer += oprot->writeString(_iter1316->first); - xfer += oprot->writeString(_iter1316->second); + xfer += oprot->writeString(_iter1315->first); + xfer += oprot->writeString(_iter1315->second); } xfer += oprot->writeMapEnd(); } @@ -21347,11 +21347,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 _iter1317; - for (_iter1317 = (*(this->part_vals)).begin(); _iter1317 != (*(this->part_vals)).end(); ++_iter1317) + std::map ::const_iterator _iter1316; + for (_iter1316 = (*(this->part_vals)).begin(); _iter1316 != (*(this->part_vals)).end(); ++_iter1316) { - xfer += oprot->writeString(_iter1317->first); - xfer += oprot->writeString(_iter1317->second); + xfer += oprot->writeString(_iter1316->first); + xfer += oprot->writeString(_iter1316->second); } xfer += oprot->writeMapEnd(); } @@ -22787,14 +22787,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1318; - ::apache::thrift::protocol::TType _etype1321; - xfer += iprot->readListBegin(_etype1321, _size1318); - this->success.resize(_size1318); - uint32_t _i1322; - for (_i1322 = 0; _i1322 < _size1318; ++_i1322) + 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) { - xfer += this->success[_i1322].read(iprot); + xfer += this->success[_i1321].read(iprot); } xfer += iprot->readListEnd(); } @@ -22841,10 +22841,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 _iter1323; - for (_iter1323 = this->success.begin(); _iter1323 != this->success.end(); ++_iter1323) + std::vector ::const_iterator _iter1322; + for (_iter1322 = this->success.begin(); _iter1322 != this->success.end(); ++_iter1322) { - xfer += (*_iter1323).write(oprot); + xfer += (*_iter1322).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22893,14 +22893,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1324; - ::apache::thrift::protocol::TType _etype1327; - xfer += iprot->readListBegin(_etype1327, _size1324); - (*(this->success)).resize(_size1324); - uint32_t _i1328; - for (_i1328 = 0; _i1328 < _size1324; ++_i1328) + uint32_t _size1323; + ::apache::thrift::protocol::TType _etype1326; + xfer += iprot->readListBegin(_etype1326, _size1323); + (*(this->success)).resize(_size1323); + uint32_t _i1327; + for (_i1327 = 0; _i1327 < _size1323; ++_i1327) { - xfer += (*(this->success))[_i1328].read(iprot); + xfer += (*(this->success))[_i1327].read(iprot); } xfer += iprot->readListEnd(); } @@ -23078,14 +23078,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1329; - ::apache::thrift::protocol::TType _etype1332; - xfer += iprot->readListBegin(_etype1332, _size1329); - this->success.resize(_size1329); - uint32_t _i1333; - for (_i1333 = 0; _i1333 < _size1329; ++_i1333) + uint32_t _size1328; + ::apache::thrift::protocol::TType _etype1331; + xfer += iprot->readListBegin(_etype1331, _size1328); + this->success.resize(_size1328); + uint32_t _i1332; + for (_i1332 = 0; _i1332 < _size1328; ++_i1332) { - xfer += iprot->readString(this->success[_i1333]); + xfer += iprot->readString(this->success[_i1332]); } xfer += iprot->readListEnd(); } @@ -23124,10 +23124,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 _iter1334; - for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) + std::vector ::const_iterator _iter1333; + for (_iter1333 = this->success.begin(); _iter1333 != this->success.end(); ++_iter1333) { - xfer += oprot->writeString((*_iter1334)); + xfer += oprot->writeString((*_iter1333)); } xfer += oprot->writeListEnd(); } @@ -23172,14 +23172,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1335; - ::apache::thrift::protocol::TType _etype1338; - xfer += iprot->readListBegin(_etype1338, _size1335); - (*(this->success)).resize(_size1335); - uint32_t _i1339; - for (_i1339 = 0; _i1339 < _size1335; ++_i1339) + uint32_t _size1334; + ::apache::thrift::protocol::TType _etype1337; + xfer += iprot->readListBegin(_etype1337, _size1334); + (*(this->success)).resize(_size1334); + uint32_t _i1338; + for (_i1338 = 0; _i1338 < _size1334; ++_i1338) { - xfer += iprot->readString((*(this->success))[_i1339]); + xfer += iprot->readString((*(this->success))[_i1338]); } xfer += iprot->readListEnd(); } @@ -27206,14 +27206,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1340; - ::apache::thrift::protocol::TType _etype1343; - xfer += iprot->readListBegin(_etype1343, _size1340); - this->success.resize(_size1340); - uint32_t _i1344; - for (_i1344 = 0; _i1344 < _size1340; ++_i1344) + 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) { - xfer += iprot->readString(this->success[_i1344]); + xfer += iprot->readString(this->success[_i1343]); } xfer += iprot->readListEnd(); } @@ -27252,10 +27252,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 _iter1345; - for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) + std::vector ::const_iterator _iter1344; + for (_iter1344 = this->success.begin(); _iter1344 != this->success.end(); ++_iter1344) { - xfer += oprot->writeString((*_iter1345)); + xfer += oprot->writeString((*_iter1344)); } xfer += oprot->writeListEnd(); } @@ -27300,14 +27300,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1346; - ::apache::thrift::protocol::TType _etype1349; - xfer += iprot->readListBegin(_etype1349, _size1346); - (*(this->success)).resize(_size1346); - uint32_t _i1350; - for (_i1350 = 0; _i1350 < _size1346; ++_i1350) + uint32_t _size1345; + ::apache::thrift::protocol::TType _etype1348; + xfer += iprot->readListBegin(_etype1348, _size1345); + (*(this->success)).resize(_size1345); + uint32_t _i1349; + for (_i1349 = 0; _i1349 < _size1345; ++_i1349) { - xfer += iprot->readString((*(this->success))[_i1350]); + xfer += iprot->readString((*(this->success))[_i1349]); } xfer += iprot->readListEnd(); } @@ -28267,14 +28267,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1351; - ::apache::thrift::protocol::TType _etype1354; - xfer += iprot->readListBegin(_etype1354, _size1351); - this->success.resize(_size1351); - uint32_t _i1355; - for (_i1355 = 0; _i1355 < _size1351; ++_i1355) + 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) { - xfer += iprot->readString(this->success[_i1355]); + xfer += iprot->readString(this->success[_i1354]); } xfer += iprot->readListEnd(); } @@ -28313,10 +28313,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 _iter1356; - for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356) + std::vector ::const_iterator _iter1355; + for (_iter1355 = this->success.begin(); _iter1355 != this->success.end(); ++_iter1355) { - xfer += oprot->writeString((*_iter1356)); + xfer += oprot->writeString((*_iter1355)); } xfer += oprot->writeListEnd(); } @@ -28361,14 +28361,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1357; - ::apache::thrift::protocol::TType _etype1360; - xfer += iprot->readListBegin(_etype1360, _size1357); - (*(this->success)).resize(_size1357); - uint32_t _i1361; - for (_i1361 = 0; _i1361 < _size1357; ++_i1361) + uint32_t _size1356; + ::apache::thrift::protocol::TType _etype1359; + xfer += iprot->readListBegin(_etype1359, _size1356); + (*(this->success)).resize(_size1356); + uint32_t _i1360; + for (_i1360 = 0; _i1360 < _size1356; ++_i1360) { - xfer += iprot->readString((*(this->success))[_i1361]); + xfer += iprot->readString((*(this->success))[_i1360]); } xfer += iprot->readListEnd(); } @@ -28441,9 +28441,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1362; - xfer += iprot->readI32(ecast1362); - this->principal_type = (PrincipalType::type)ecast1362; + int32_t ecast1361; + xfer += iprot->readI32(ecast1361); + this->principal_type = (PrincipalType::type)ecast1361; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28459,9 +28459,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1363; - xfer += iprot->readI32(ecast1363); - this->grantorType = (PrincipalType::type)ecast1363; + int32_t ecast1362; + xfer += iprot->readI32(ecast1362); + this->grantorType = (PrincipalType::type)ecast1362; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -28732,9 +28732,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1364; - xfer += iprot->readI32(ecast1364); - this->principal_type = (PrincipalType::type)ecast1364; + int32_t ecast1363; + xfer += iprot->readI32(ecast1363); + this->principal_type = (PrincipalType::type)ecast1363; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28965,9 +28965,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1365; - xfer += iprot->readI32(ecast1365); - this->principal_type = (PrincipalType::type)ecast1365; + int32_t ecast1364; + xfer += iprot->readI32(ecast1364); + this->principal_type = (PrincipalType::type)ecast1364; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29056,14 +29056,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1366; - ::apache::thrift::protocol::TType _etype1369; - xfer += iprot->readListBegin(_etype1369, _size1366); - this->success.resize(_size1366); - uint32_t _i1370; - for (_i1370 = 0; _i1370 < _size1366; ++_i1370) + uint32_t _size1365; + ::apache::thrift::protocol::TType _etype1368; + xfer += iprot->readListBegin(_etype1368, _size1365); + this->success.resize(_size1365); + uint32_t _i1369; + for (_i1369 = 0; _i1369 < _size1365; ++_i1369) { - xfer += this->success[_i1370].read(iprot); + xfer += this->success[_i1369].read(iprot); } xfer += iprot->readListEnd(); } @@ -29102,10 +29102,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 _iter1371; - for (_iter1371 = this->success.begin(); _iter1371 != this->success.end(); ++_iter1371) + std::vector ::const_iterator _iter1370; + for (_iter1370 = this->success.begin(); _iter1370 != this->success.end(); ++_iter1370) { - xfer += (*_iter1371).write(oprot); + xfer += (*_iter1370).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29150,14 +29150,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1372; - ::apache::thrift::protocol::TType _etype1375; - xfer += iprot->readListBegin(_etype1375, _size1372); - (*(this->success)).resize(_size1372); - uint32_t _i1376; - for (_i1376 = 0; _i1376 < _size1372; ++_i1376) + uint32_t _size1371; + ::apache::thrift::protocol::TType _etype1374; + xfer += iprot->readListBegin(_etype1374, _size1371); + (*(this->success)).resize(_size1371); + uint32_t _i1375; + for (_i1375 = 0; _i1375 < _size1371; ++_i1375) { - xfer += (*(this->success))[_i1376].read(iprot); + xfer += (*(this->success))[_i1375].read(iprot); } xfer += iprot->readListEnd(); } @@ -29853,14 +29853,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 _size1377; - ::apache::thrift::protocol::TType _etype1380; - xfer += iprot->readListBegin(_etype1380, _size1377); - this->group_names.resize(_size1377); - uint32_t _i1381; - for (_i1381 = 0; _i1381 < _size1377; ++_i1381) + uint32_t _size1376; + ::apache::thrift::protocol::TType _etype1379; + xfer += iprot->readListBegin(_etype1379, _size1376); + this->group_names.resize(_size1376); + uint32_t _i1380; + for (_i1380 = 0; _i1380 < _size1376; ++_i1380) { - xfer += iprot->readString(this->group_names[_i1381]); + xfer += iprot->readString(this->group_names[_i1380]); } xfer += iprot->readListEnd(); } @@ -29897,10 +29897,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 _iter1382; - for (_iter1382 = this->group_names.begin(); _iter1382 != this->group_names.end(); ++_iter1382) + std::vector ::const_iterator _iter1381; + for (_iter1381 = this->group_names.begin(); _iter1381 != this->group_names.end(); ++_iter1381) { - xfer += oprot->writeString((*_iter1382)); + xfer += oprot->writeString((*_iter1381)); } xfer += oprot->writeListEnd(); } @@ -29932,10 +29932,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 _iter1383; - for (_iter1383 = (*(this->group_names)).begin(); _iter1383 != (*(this->group_names)).end(); ++_iter1383) + std::vector ::const_iterator _iter1382; + for (_iter1382 = (*(this->group_names)).begin(); _iter1382 != (*(this->group_names)).end(); ++_iter1382) { - xfer += oprot->writeString((*_iter1383)); + xfer += oprot->writeString((*_iter1382)); } xfer += oprot->writeListEnd(); } @@ -30110,9 +30110,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1384; - xfer += iprot->readI32(ecast1384); - this->principal_type = (PrincipalType::type)ecast1384; + int32_t ecast1383; + xfer += iprot->readI32(ecast1383); + this->principal_type = (PrincipalType::type)ecast1383; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30217,14 +30217,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1385; - ::apache::thrift::protocol::TType _etype1388; - xfer += iprot->readListBegin(_etype1388, _size1385); - this->success.resize(_size1385); - uint32_t _i1389; - for (_i1389 = 0; _i1389 < _size1385; ++_i1389) + 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) { - xfer += this->success[_i1389].read(iprot); + xfer += this->success[_i1388].read(iprot); } xfer += iprot->readListEnd(); } @@ -30263,10 +30263,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 _iter1390; - for (_iter1390 = this->success.begin(); _iter1390 != this->success.end(); ++_iter1390) + std::vector ::const_iterator _iter1389; + for (_iter1389 = this->success.begin(); _iter1389 != this->success.end(); ++_iter1389) { - xfer += (*_iter1390).write(oprot); + xfer += (*_iter1389).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30311,14 +30311,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1391; - ::apache::thrift::protocol::TType _etype1394; - xfer += iprot->readListBegin(_etype1394, _size1391); - (*(this->success)).resize(_size1391); - uint32_t _i1395; - for (_i1395 = 0; _i1395 < _size1391; ++_i1395) + uint32_t _size1390; + ::apache::thrift::protocol::TType _etype1393; + xfer += iprot->readListBegin(_etype1393, _size1390); + (*(this->success)).resize(_size1390); + uint32_t _i1394; + for (_i1394 = 0; _i1394 < _size1390; ++_i1394) { - xfer += (*(this->success))[_i1395].read(iprot); + xfer += (*(this->success))[_i1394].read(iprot); } xfer += iprot->readListEnd(); } @@ -31006,14 +31006,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 _size1396; - ::apache::thrift::protocol::TType _etype1399; - xfer += iprot->readListBegin(_etype1399, _size1396); - this->group_names.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->group_names.resize(_size1395); + uint32_t _i1399; + for (_i1399 = 0; _i1399 < _size1395; ++_i1399) { - xfer += iprot->readString(this->group_names[_i1400]); + xfer += iprot->readString(this->group_names[_i1399]); } xfer += iprot->readListEnd(); } @@ -31046,10 +31046,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 _iter1401; - for (_iter1401 = this->group_names.begin(); _iter1401 != this->group_names.end(); ++_iter1401) + std::vector ::const_iterator _iter1400; + for (_iter1400 = this->group_names.begin(); _iter1400 != this->group_names.end(); ++_iter1400) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1400)); } xfer += oprot->writeListEnd(); } @@ -31077,10 +31077,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 _iter1402; - for (_iter1402 = (*(this->group_names)).begin(); _iter1402 != (*(this->group_names)).end(); ++_iter1402) + std::vector ::const_iterator _iter1401; + for (_iter1401 = (*(this->group_names)).begin(); _iter1401 != (*(this->group_names)).end(); ++_iter1401) { - xfer += oprot->writeString((*_iter1402)); + xfer += oprot->writeString((*_iter1401)); } xfer += oprot->writeListEnd(); } @@ -31121,14 +31121,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1403; - ::apache::thrift::protocol::TType _etype1406; - xfer += iprot->readListBegin(_etype1406, _size1403); - this->success.resize(_size1403); - uint32_t _i1407; - for (_i1407 = 0; _i1407 < _size1403; ++_i1407) + 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) { - xfer += iprot->readString(this->success[_i1407]); + xfer += iprot->readString(this->success[_i1406]); } xfer += iprot->readListEnd(); } @@ -31167,10 +31167,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 _iter1408; - for (_iter1408 = this->success.begin(); _iter1408 != this->success.end(); ++_iter1408) + std::vector ::const_iterator _iter1407; + for (_iter1407 = this->success.begin(); _iter1407 != this->success.end(); ++_iter1407) { - xfer += oprot->writeString((*_iter1408)); + xfer += oprot->writeString((*_iter1407)); } xfer += oprot->writeListEnd(); } @@ -31215,14 +31215,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1409; - ::apache::thrift::protocol::TType _etype1412; - xfer += iprot->readListBegin(_etype1412, _size1409); - (*(this->success)).resize(_size1409); - uint32_t _i1413; - for (_i1413 = 0; _i1413 < _size1409; ++_i1413) + uint32_t _size1408; + ::apache::thrift::protocol::TType _etype1411; + xfer += iprot->readListBegin(_etype1411, _size1408); + (*(this->success)).resize(_size1408); + uint32_t _i1412; + for (_i1412 = 0; _i1412 < _size1408; ++_i1412) { - xfer += iprot->readString((*(this->success))[_i1413]); + xfer += iprot->readString((*(this->success))[_i1412]); } xfer += iprot->readListEnd(); } @@ -32533,14 +32533,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1414; - ::apache::thrift::protocol::TType _etype1417; - xfer += iprot->readListBegin(_etype1417, _size1414); - this->success.resize(_size1414); - uint32_t _i1418; - for (_i1418 = 0; _i1418 < _size1414; ++_i1418) + 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) { - xfer += iprot->readString(this->success[_i1418]); + xfer += iprot->readString(this->success[_i1417]); } xfer += iprot->readListEnd(); } @@ -32571,10 +32571,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 _iter1419; - for (_iter1419 = this->success.begin(); _iter1419 != this->success.end(); ++_iter1419) + std::vector ::const_iterator _iter1418; + for (_iter1418 = this->success.begin(); _iter1418 != this->success.end(); ++_iter1418) { - xfer += oprot->writeString((*_iter1419)); + xfer += oprot->writeString((*_iter1418)); } xfer += oprot->writeListEnd(); } @@ -32615,14 +32615,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1420; - ::apache::thrift::protocol::TType _etype1423; - xfer += iprot->readListBegin(_etype1423, _size1420); - (*(this->success)).resize(_size1420); - uint32_t _i1424; - for (_i1424 = 0; _i1424 < _size1420; ++_i1424) + uint32_t _size1419; + ::apache::thrift::protocol::TType _etype1422; + xfer += iprot->readListBegin(_etype1422, _size1419); + (*(this->success)).resize(_size1419); + uint32_t _i1423; + for (_i1423 = 0; _i1423 < _size1419; ++_i1423) { - xfer += iprot->readString((*(this->success))[_i1424]); + xfer += iprot->readString((*(this->success))[_i1423]); } xfer += iprot->readListEnd(); } @@ -33348,14 +33348,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1425; - ::apache::thrift::protocol::TType _etype1428; - xfer += iprot->readListBegin(_etype1428, _size1425); - this->success.resize(_size1425); - uint32_t _i1429; - for (_i1429 = 0; _i1429 < _size1425; ++_i1429) + 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) { - xfer += iprot->readString(this->success[_i1429]); + xfer += iprot->readString(this->success[_i1428]); } xfer += iprot->readListEnd(); } @@ -33386,10 +33386,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 _iter1430; - for (_iter1430 = this->success.begin(); _iter1430 != this->success.end(); ++_iter1430) + std::vector ::const_iterator _iter1429; + for (_iter1429 = this->success.begin(); _iter1429 != this->success.end(); ++_iter1429) { - xfer += oprot->writeString((*_iter1430)); + xfer += oprot->writeString((*_iter1429)); } xfer += oprot->writeListEnd(); } @@ -33430,14 +33430,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1431; - ::apache::thrift::protocol::TType _etype1434; - xfer += iprot->readListBegin(_etype1434, _size1431); - (*(this->success)).resize(_size1431); - uint32_t _i1435; - for (_i1435 = 0; _i1435 < _size1431; ++_i1435) + uint32_t _size1430; + ::apache::thrift::protocol::TType _etype1433; + xfer += iprot->readListBegin(_etype1433, _size1430); + (*(this->success)).resize(_size1430); + uint32_t _i1434; + for (_i1434 = 0; _i1434 < _size1430; ++_i1434) { - xfer += iprot->readString((*(this->success))[_i1435]); + xfer += iprot->readString((*(this->success))[_i1434]); } 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 7eaf395..4fb7183 100644 --- metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -11092,14 +11092,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 { @@ -11135,9 +11135,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(); @@ -11268,14 +11268,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 { @@ -11311,9 +11311,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(); @@ -12314,18 +12314,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 { @@ -12361,10 +12361,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(); @@ -12568,15 +12568,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 { @@ -12628,9 +12628,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(); @@ -12872,15 +12872,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 { @@ -12932,9 +12932,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(); @@ -13148,15 +13148,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 { @@ -13208,9 +13208,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(); @@ -13452,15 +13452,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 { @@ -13512,9 +13512,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(); @@ -14122,15 +14122,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 { @@ -14140,15 +14140,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 { @@ -14184,9 +14184,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(); @@ -14201,9 +14201,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(); @@ -15475,14 +15475,14 @@ class ThriftHiveMetastore_truncate_table_args { case 3: if ($ftype == TType::LST) { $this->partNames = 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->partNames []= $elem667; + $elem666 = null; + $xfer += $input->readString($elem666); + $this->partNames []= $elem666; } $xfer += $input->readListEnd(); } else { @@ -15520,9 +15520,9 @@ class ThriftHiveMetastore_truncate_table_args { { $output->writeListBegin(TType::STRING, count($this->partNames)); { - foreach ($this->partNames as $iter668) + foreach ($this->partNames as $iter667) { - $xfer += $output->writeString($iter668); + $xfer += $output->writeString($iter667); } } $output->writeListEnd(); @@ -15773,14 +15773,14 @@ class ThriftHiveMetastore_get_tables_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 { @@ -15816,9 +15816,9 @@ class ThriftHiveMetastore_get_tables_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(); @@ -16020,14 +16020,14 @@ class ThriftHiveMetastore_get_tables_by_type_result { case 0: if ($ftype == TType::LST) { $this->success = 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->success []= $elem681; + $elem680 = null; + $xfer += $input->readString($elem680); + $this->success []= $elem680; } $xfer += $input->readListEnd(); } else { @@ -16063,9 +16063,9 @@ class ThriftHiveMetastore_get_tables_by_type_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter682) + foreach ($this->success as $iter681) { - $xfer += $output->writeString($iter682); + $xfer += $output->writeString($iter681); } } $output->writeListEnd(); @@ -16170,14 +16170,14 @@ class ThriftHiveMetastore_get_table_meta_args { case 3: if ($ftype == TType::LST) { $this->tbl_types = 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; - $xfer += $input->readString($elem688); - $this->tbl_types []= $elem688; + $elem687 = null; + $xfer += $input->readString($elem687); + $this->tbl_types []= $elem687; } $xfer += $input->readListEnd(); } else { @@ -16215,9 +16215,9 @@ class ThriftHiveMetastore_get_table_meta_args { { $output->writeListBegin(TType::STRING, count($this->tbl_types)); { - foreach ($this->tbl_types as $iter689) + foreach ($this->tbl_types as $iter688) { - $xfer += $output->writeString($iter689); + $xfer += $output->writeString($iter688); } } $output->writeListEnd(); @@ -16294,15 +16294,15 @@ class ThriftHiveMetastore_get_table_meta_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; - $elem695 = new \metastore\TableMeta(); - $xfer += $elem695->read($input); - $this->success []= $elem695; + $elem694 = null; + $elem694 = new \metastore\TableMeta(); + $xfer += $elem694->read($input); + $this->success []= $elem694; } $xfer += $input->readListEnd(); } else { @@ -16338,9 +16338,9 @@ class ThriftHiveMetastore_get_table_meta_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter696) + foreach ($this->success as $iter695) { - $xfer += $iter696->write($output); + $xfer += $iter695->write($output); } } $output->writeListEnd(); @@ -16496,14 +16496,14 @@ class ThriftHiveMetastore_get_all_tables_result { case 0: if ($ftype == TType::LST) { $this->success = 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->success []= $elem702; + $elem701 = null; + $xfer += $input->readString($elem701); + $this->success []= $elem701; } $xfer += $input->readListEnd(); } else { @@ -16539,9 +16539,9 @@ class ThriftHiveMetastore_get_all_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter703) + foreach ($this->success as $iter702) { - $xfer += $output->writeString($iter703); + $xfer += $output->writeString($iter702); } } $output->writeListEnd(); @@ -16856,14 +16856,14 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { case 2: if ($ftype == TType::LST) { $this->tbl_names = 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; - $xfer += $input->readString($elem709); - $this->tbl_names []= $elem709; + $elem708 = null; + $xfer += $input->readString($elem708); + $this->tbl_names []= $elem708; } $xfer += $input->readListEnd(); } else { @@ -16896,9 +16896,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter710) + foreach ($this->tbl_names as $iter709) { - $xfer += $output->writeString($iter710); + $xfer += $output->writeString($iter709); } } $output->writeListEnd(); @@ -16963,15 +16963,15 @@ class ThriftHiveMetastore_get_table_objects_by_name_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; - $elem716 = new \metastore\Table(); - $xfer += $elem716->read($input); - $this->success []= $elem716; + $elem715 = null; + $elem715 = new \metastore\Table(); + $xfer += $elem715->read($input); + $this->success []= $elem715; } $xfer += $input->readListEnd(); } else { @@ -16999,9 +16999,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter717) + foreach ($this->success as $iter716) { - $xfer += $iter717->write($output); + $xfer += $iter716->write($output); } } $output->writeListEnd(); @@ -17667,14 +17667,14 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $xfer += $input->readString($elem723); - $this->success []= $elem723; + $elem722 = null; + $xfer += $input->readString($elem722); + $this->success []= $elem722; } $xfer += $input->readListEnd(); } else { @@ -17726,9 +17726,9 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter724) + foreach ($this->success as $iter723) { - $xfer += $output->writeString($iter724); + $xfer += $output->writeString($iter723); } } $output->writeListEnd(); @@ -19041,15 +19041,15 @@ class ThriftHiveMetastore_add_partitions_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\Partition(); - $xfer += $elem730->read($input); - $this->new_parts []= $elem730; + $elem729 = null; + $elem729 = new \metastore\Partition(); + $xfer += $elem729->read($input); + $this->new_parts []= $elem729; } $xfer += $input->readListEnd(); } else { @@ -19077,9 +19077,9 @@ class ThriftHiveMetastore_add_partitions_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(); @@ -19294,15 +19294,15 @@ class ThriftHiveMetastore_add_partitions_pspec_args { case 1: if ($ftype == TType::LST) { $this->new_parts = 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; - $elem737 = new \metastore\PartitionSpec(); - $xfer += $elem737->read($input); - $this->new_parts []= $elem737; + $elem736 = null; + $elem736 = new \metastore\PartitionSpec(); + $xfer += $elem736->read($input); + $this->new_parts []= $elem736; } $xfer += $input->readListEnd(); } else { @@ -19330,9 +19330,9 @@ class ThriftHiveMetastore_add_partitions_pspec_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter738) + foreach ($this->new_parts as $iter737) { - $xfer += $iter738->write($output); + $xfer += $iter737->write($output); } } $output->writeListEnd(); @@ -19582,14 +19582,14 @@ class ThriftHiveMetastore_append_partition_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 { @@ -19627,9 +19627,9 @@ class ThriftHiveMetastore_append_partition_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(); @@ -20131,14 +20131,14 @@ class ThriftHiveMetastore_append_partition_with_environment_context_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 { @@ -20184,9 +20184,9 @@ class ThriftHiveMetastore_append_partition_with_environment_context_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(); @@ -21040,14 +21040,14 @@ class ThriftHiveMetastore_drop_partition_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 { @@ -21092,9 +21092,9 @@ class ThriftHiveMetastore_drop_partition_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(); @@ -21347,14 +21347,14 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_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 { @@ -21407,9 +21407,9 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_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(); @@ -22423,14 +22423,14 @@ class ThriftHiveMetastore_get_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size767 = 0; - $_etype770 = 0; - $xfer += $input->readListBegin($_etype770, $_size767); - for ($_i771 = 0; $_i771 < $_size767; ++$_i771) + $_size766 = 0; + $_etype769 = 0; + $xfer += $input->readListBegin($_etype769, $_size766); + for ($_i770 = 0; $_i770 < $_size766; ++$_i770) { - $elem772 = null; - $xfer += $input->readString($elem772); - $this->part_vals []= $elem772; + $elem771 = null; + $xfer += $input->readString($elem771); + $this->part_vals []= $elem771; } $xfer += $input->readListEnd(); } else { @@ -22468,9 +22468,9 @@ class ThriftHiveMetastore_get_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter773) + foreach ($this->part_vals as $iter772) { - $xfer += $output->writeString($iter773); + $xfer += $output->writeString($iter772); } } $output->writeListEnd(); @@ -22712,17 +22712,17 @@ class ThriftHiveMetastore_exchange_partition_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size774 = 0; - $_ktype775 = 0; - $_vtype776 = 0; - $xfer += $input->readMapBegin($_ktype775, $_vtype776, $_size774); - for ($_i778 = 0; $_i778 < $_size774; ++$_i778) + $_size773 = 0; + $_ktype774 = 0; + $_vtype775 = 0; + $xfer += $input->readMapBegin($_ktype774, $_vtype775, $_size773); + for ($_i777 = 0; $_i777 < $_size773; ++$_i777) { - $key779 = ''; - $val780 = ''; - $xfer += $input->readString($key779); - $xfer += $input->readString($val780); - $this->partitionSpecs[$key779] = $val780; + $key778 = ''; + $val779 = ''; + $xfer += $input->readString($key778); + $xfer += $input->readString($val779); + $this->partitionSpecs[$key778] = $val779; } $xfer += $input->readMapEnd(); } else { @@ -22778,10 +22778,10 @@ class ThriftHiveMetastore_exchange_partition_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter781 => $viter782) + foreach ($this->partitionSpecs as $kiter780 => $viter781) { - $xfer += $output->writeString($kiter781); - $xfer += $output->writeString($viter782); + $xfer += $output->writeString($kiter780); + $xfer += $output->writeString($viter781); } } $output->writeMapEnd(); @@ -23093,17 +23093,17 @@ class ThriftHiveMetastore_exchange_partitions_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size783 = 0; - $_ktype784 = 0; - $_vtype785 = 0; - $xfer += $input->readMapBegin($_ktype784, $_vtype785, $_size783); - for ($_i787 = 0; $_i787 < $_size783; ++$_i787) + $_size782 = 0; + $_ktype783 = 0; + $_vtype784 = 0; + $xfer += $input->readMapBegin($_ktype783, $_vtype784, $_size782); + for ($_i786 = 0; $_i786 < $_size782; ++$_i786) { - $key788 = ''; - $val789 = ''; - $xfer += $input->readString($key788); - $xfer += $input->readString($val789); - $this->partitionSpecs[$key788] = $val789; + $key787 = ''; + $val788 = ''; + $xfer += $input->readString($key787); + $xfer += $input->readString($val788); + $this->partitionSpecs[$key787] = $val788; } $xfer += $input->readMapEnd(); } else { @@ -23159,10 +23159,10 @@ class ThriftHiveMetastore_exchange_partitions_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter790 => $viter791) + foreach ($this->partitionSpecs as $kiter789 => $viter790) { - $xfer += $output->writeString($kiter790); - $xfer += $output->writeString($viter791); + $xfer += $output->writeString($kiter789); + $xfer += $output->writeString($viter790); } } $output->writeMapEnd(); @@ -23295,15 +23295,15 @@ class ThriftHiveMetastore_exchange_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem797 = new \metastore\Partition(); - $xfer += $elem797->read($input); - $this->success []= $elem797; + $elem796 = null; + $elem796 = new \metastore\Partition(); + $xfer += $elem796->read($input); + $this->success []= $elem796; } $xfer += $input->readListEnd(); } else { @@ -23363,9 +23363,9 @@ class ThriftHiveMetastore_exchange_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter798) + foreach ($this->success as $iter797) { - $xfer += $iter798->write($output); + $xfer += $iter797->write($output); } } $output->writeListEnd(); @@ -23511,14 +23511,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size799 = 0; - $_etype802 = 0; - $xfer += $input->readListBegin($_etype802, $_size799); - for ($_i803 = 0; $_i803 < $_size799; ++$_i803) + $_size798 = 0; + $_etype801 = 0; + $xfer += $input->readListBegin($_etype801, $_size798); + for ($_i802 = 0; $_i802 < $_size798; ++$_i802) { - $elem804 = null; - $xfer += $input->readString($elem804); - $this->part_vals []= $elem804; + $elem803 = null; + $xfer += $input->readString($elem803); + $this->part_vals []= $elem803; } $xfer += $input->readListEnd(); } else { @@ -23535,14 +23535,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size805 = 0; - $_etype808 = 0; - $xfer += $input->readListBegin($_etype808, $_size805); - for ($_i809 = 0; $_i809 < $_size805; ++$_i809) + $_size804 = 0; + $_etype807 = 0; + $xfer += $input->readListBegin($_etype807, $_size804); + for ($_i808 = 0; $_i808 < $_size804; ++$_i808) { - $elem810 = null; - $xfer += $input->readString($elem810); - $this->group_names []= $elem810; + $elem809 = null; + $xfer += $input->readString($elem809); + $this->group_names []= $elem809; } $xfer += $input->readListEnd(); } else { @@ -23580,9 +23580,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter811) + foreach ($this->part_vals as $iter810) { - $xfer += $output->writeString($iter811); + $xfer += $output->writeString($iter810); } } $output->writeListEnd(); @@ -23602,9 +23602,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter812) + foreach ($this->group_names as $iter811) { - $xfer += $output->writeString($iter812); + $xfer += $output->writeString($iter811); } } $output->writeListEnd(); @@ -24195,15 +24195,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem818 = new \metastore\Partition(); - $xfer += $elem818->read($input); - $this->success []= $elem818; + $elem817 = null; + $elem817 = new \metastore\Partition(); + $xfer += $elem817->read($input); + $this->success []= $elem817; } $xfer += $input->readListEnd(); } else { @@ -24247,9 +24247,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter819) + foreach ($this->success as $iter818) { - $xfer += $iter819->write($output); + $xfer += $iter818->write($output); } } $output->writeListEnd(); @@ -24395,14 +24395,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = 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; - $xfer += $input->readString($elem825); - $this->group_names []= $elem825; + $elem824 = null; + $xfer += $input->readString($elem824); + $this->group_names []= $elem824; } $xfer += $input->readListEnd(); } else { @@ -24450,9 +24450,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter826) + foreach ($this->group_names as $iter825) { - $xfer += $output->writeString($iter826); + $xfer += $output->writeString($iter825); } } $output->writeListEnd(); @@ -24541,15 +24541,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_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\Partition(); - $xfer += $elem832->read($input); - $this->success []= $elem832; + $elem831 = null; + $elem831 = new \metastore\Partition(); + $xfer += $elem831->read($input); + $this->success []= $elem831; } $xfer += $input->readListEnd(); } else { @@ -24593,9 +24593,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_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(); @@ -24815,15 +24815,15 @@ class ThriftHiveMetastore_get_partitions_pspec_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; - $elem839 = new \metastore\PartitionSpec(); - $xfer += $elem839->read($input); - $this->success []= $elem839; + $elem838 = null; + $elem838 = new \metastore\PartitionSpec(); + $xfer += $elem838->read($input); + $this->success []= $elem838; } $xfer += $input->readListEnd(); } else { @@ -24867,9 +24867,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter840) + foreach ($this->success as $iter839) { - $xfer += $iter840->write($output); + $xfer += $iter839->write($output); } } $output->writeListEnd(); @@ -25076,14 +25076,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = 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->success []= $elem846; + $elem845 = null; + $xfer += $input->readString($elem845); + $this->success []= $elem845; } $xfer += $input->readListEnd(); } else { @@ -25119,9 +25119,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter847) + foreach ($this->success as $iter846) { - $xfer += $output->writeString($iter847); + $xfer += $output->writeString($iter846); } } $output->writeListEnd(); @@ -25237,14 +25237,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = 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; - $xfer += $input->readString($elem853); - $this->part_vals []= $elem853; + $elem852 = null; + $xfer += $input->readString($elem852); + $this->part_vals []= $elem852; } $xfer += $input->readListEnd(); } else { @@ -25289,9 +25289,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter854) + foreach ($this->part_vals as $iter853) { - $xfer += $output->writeString($iter854); + $xfer += $output->writeString($iter853); } } $output->writeListEnd(); @@ -25385,15 +25385,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem860 = new \metastore\Partition(); - $xfer += $elem860->read($input); - $this->success []= $elem860; + $elem859 = null; + $elem859 = new \metastore\Partition(); + $xfer += $elem859->read($input); + $this->success []= $elem859; } $xfer += $input->readListEnd(); } else { @@ -25437,9 +25437,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter861) + foreach ($this->success as $iter860) { - $xfer += $iter861->write($output); + $xfer += $iter860->write($output); } } $output->writeListEnd(); @@ -25586,14 +25586,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size862 = 0; - $_etype865 = 0; - $xfer += $input->readListBegin($_etype865, $_size862); - for ($_i866 = 0; $_i866 < $_size862; ++$_i866) + $_size861 = 0; + $_etype864 = 0; + $xfer += $input->readListBegin($_etype864, $_size861); + for ($_i865 = 0; $_i865 < $_size861; ++$_i865) { - $elem867 = null; - $xfer += $input->readString($elem867); - $this->part_vals []= $elem867; + $elem866 = null; + $xfer += $input->readString($elem866); + $this->part_vals []= $elem866; } $xfer += $input->readListEnd(); } else { @@ -25617,14 +25617,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size868 = 0; - $_etype871 = 0; - $xfer += $input->readListBegin($_etype871, $_size868); - for ($_i872 = 0; $_i872 < $_size868; ++$_i872) + $_size867 = 0; + $_etype870 = 0; + $xfer += $input->readListBegin($_etype870, $_size867); + for ($_i871 = 0; $_i871 < $_size867; ++$_i871) { - $elem873 = null; - $xfer += $input->readString($elem873); - $this->group_names []= $elem873; + $elem872 = null; + $xfer += $input->readString($elem872); + $this->group_names []= $elem872; } $xfer += $input->readListEnd(); } else { @@ -25662,9 +25662,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter874) + foreach ($this->part_vals as $iter873) { - $xfer += $output->writeString($iter874); + $xfer += $output->writeString($iter873); } } $output->writeListEnd(); @@ -25689,9 +25689,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter875) + foreach ($this->group_names as $iter874) { - $xfer += $output->writeString($iter875); + $xfer += $output->writeString($iter874); } } $output->writeListEnd(); @@ -25780,15 +25780,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem881 = new \metastore\Partition(); - $xfer += $elem881->read($input); - $this->success []= $elem881; + $elem880 = null; + $elem880 = new \metastore\Partition(); + $xfer += $elem880->read($input); + $this->success []= $elem880; } $xfer += $input->readListEnd(); } else { @@ -25832,9 +25832,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter882) + foreach ($this->success as $iter881) { - $xfer += $iter882->write($output); + $xfer += $iter881->write($output); } } $output->writeListEnd(); @@ -25955,14 +25955,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = 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->part_vals []= $elem888; + $elem887 = null; + $xfer += $input->readString($elem887); + $this->part_vals []= $elem887; } $xfer += $input->readListEnd(); } else { @@ -26007,9 +26007,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter889) + foreach ($this->part_vals as $iter888) { - $xfer += $output->writeString($iter889); + $xfer += $output->writeString($iter888); } } $output->writeListEnd(); @@ -26102,14 +26102,14 @@ class ThriftHiveMetastore_get_partition_names_ps_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; - $xfer += $input->readString($elem895); - $this->success []= $elem895; + $elem894 = null; + $xfer += $input->readString($elem894); + $this->success []= $elem894; } $xfer += $input->readListEnd(); } else { @@ -26153,9 +26153,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter896) + foreach ($this->success as $iter895) { - $xfer += $output->writeString($iter896); + $xfer += $output->writeString($iter895); } } $output->writeListEnd(); @@ -26398,15 +26398,15 @@ class ThriftHiveMetastore_get_partitions_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\Partition(); - $xfer += $elem902->read($input); - $this->success []= $elem902; + $elem901 = null; + $elem901 = new \metastore\Partition(); + $xfer += $elem901->read($input); + $this->success []= $elem901; } $xfer += $input->readListEnd(); } else { @@ -26450,9 +26450,9 @@ class ThriftHiveMetastore_get_partitions_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(); @@ -26695,15 +26695,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem909 = new \metastore\PartitionSpec(); - $xfer += $elem909->read($input); - $this->success []= $elem909; + $elem908 = null; + $elem908 = new \metastore\PartitionSpec(); + $xfer += $elem908->read($input); + $this->success []= $elem908; } $xfer += $input->readListEnd(); } else { @@ -26747,9 +26747,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter910) + foreach ($this->success as $iter909) { - $xfer += $iter910->write($output); + $xfer += $iter909->write($output); } } $output->writeListEnd(); @@ -27315,14 +27315,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = 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; - $xfer += $input->readString($elem916); - $this->names []= $elem916; + $elem915 = null; + $xfer += $input->readString($elem915); + $this->names []= $elem915; } $xfer += $input->readListEnd(); } else { @@ -27360,9 +27360,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter917) + foreach ($this->names as $iter916) { - $xfer += $output->writeString($iter917); + $xfer += $output->writeString($iter916); } } $output->writeListEnd(); @@ -27451,15 +27451,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = 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->success []= $elem923; + $elem922 = null; + $elem922 = new \metastore\Partition(); + $xfer += $elem922->read($input); + $this->success []= $elem922; } $xfer += $input->readListEnd(); } else { @@ -27503,9 +27503,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter924) + foreach ($this->success as $iter923) { - $xfer += $iter924->write($output); + $xfer += $iter923->write($output); } } $output->writeListEnd(); @@ -27844,15 +27844,15 @@ class ThriftHiveMetastore_alter_partitions_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 { @@ -27890,9 +27890,9 @@ class ThriftHiveMetastore_alter_partitions_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(); @@ -28107,15 +28107,15 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->new_parts = 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; - $elem937 = new \metastore\Partition(); - $xfer += $elem937->read($input); - $this->new_parts []= $elem937; + $elem936 = null; + $elem936 = new \metastore\Partition(); + $xfer += $elem936->read($input); + $this->new_parts []= $elem936; } $xfer += $input->readListEnd(); } else { @@ -28161,9 +28161,9 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter938) + foreach ($this->new_parts as $iter937) { - $xfer += $iter938->write($output); + $xfer += $iter937->write($output); } } $output->writeListEnd(); @@ -28641,14 +28641,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: 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 { @@ -28694,9 +28694,9 @@ class ThriftHiveMetastore_rename_partition_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(); @@ -28881,14 +28881,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = 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->part_vals []= $elem951; + $elem950 = null; + $xfer += $input->readString($elem950); + $this->part_vals []= $elem950; } $xfer += $input->readListEnd(); } else { @@ -28923,9 +28923,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter952) + foreach ($this->part_vals as $iter951) { - $xfer += $output->writeString($iter952); + $xfer += $output->writeString($iter951); } } $output->writeListEnd(); @@ -29379,14 +29379,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size953 = 0; - $_etype956 = 0; - $xfer += $input->readListBegin($_etype956, $_size953); - for ($_i957 = 0; $_i957 < $_size953; ++$_i957) + $_size952 = 0; + $_etype955 = 0; + $xfer += $input->readListBegin($_etype955, $_size952); + for ($_i956 = 0; $_i956 < $_size952; ++$_i956) { - $elem958 = null; - $xfer += $input->readString($elem958); - $this->success []= $elem958; + $elem957 = null; + $xfer += $input->readString($elem957); + $this->success []= $elem957; } $xfer += $input->readListEnd(); } else { @@ -29422,9 +29422,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter959) + foreach ($this->success as $iter958) { - $xfer += $output->writeString($iter959); + $xfer += $output->writeString($iter958); } } $output->writeListEnd(); @@ -29584,17 +29584,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size960 = 0; - $_ktype961 = 0; - $_vtype962 = 0; - $xfer += $input->readMapBegin($_ktype961, $_vtype962, $_size960); - for ($_i964 = 0; $_i964 < $_size960; ++$_i964) + $_size959 = 0; + $_ktype960 = 0; + $_vtype961 = 0; + $xfer += $input->readMapBegin($_ktype960, $_vtype961, $_size959); + for ($_i963 = 0; $_i963 < $_size959; ++$_i963) { - $key965 = ''; - $val966 = ''; - $xfer += $input->readString($key965); - $xfer += $input->readString($val966); - $this->success[$key965] = $val966; + $key964 = ''; + $val965 = ''; + $xfer += $input->readString($key964); + $xfer += $input->readString($val965); + $this->success[$key964] = $val965; } $xfer += $input->readMapEnd(); } else { @@ -29630,10 +29630,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter967 => $viter968) + foreach ($this->success as $kiter966 => $viter967) { - $xfer += $output->writeString($kiter967); - $xfer += $output->writeString($viter968); + $xfer += $output->writeString($kiter966); + $xfer += $output->writeString($viter967); } } $output->writeMapEnd(); @@ -29753,17 +29753,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size969 = 0; - $_ktype970 = 0; - $_vtype971 = 0; - $xfer += $input->readMapBegin($_ktype970, $_vtype971, $_size969); - for ($_i973 = 0; $_i973 < $_size969; ++$_i973) + $_size968 = 0; + $_ktype969 = 0; + $_vtype970 = 0; + $xfer += $input->readMapBegin($_ktype969, $_vtype970, $_size968); + for ($_i972 = 0; $_i972 < $_size968; ++$_i972) { - $key974 = ''; - $val975 = ''; - $xfer += $input->readString($key974); - $xfer += $input->readString($val975); - $this->part_vals[$key974] = $val975; + $key973 = ''; + $val974 = ''; + $xfer += $input->readString($key973); + $xfer += $input->readString($val974); + $this->part_vals[$key973] = $val974; } $xfer += $input->readMapEnd(); } else { @@ -29808,10 +29808,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter976 => $viter977) + foreach ($this->part_vals as $kiter975 => $viter976) { - $xfer += $output->writeString($kiter976); - $xfer += $output->writeString($viter977); + $xfer += $output->writeString($kiter975); + $xfer += $output->writeString($viter976); } } $output->writeMapEnd(); @@ -30133,17 +30133,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size978 = 0; - $_ktype979 = 0; - $_vtype980 = 0; - $xfer += $input->readMapBegin($_ktype979, $_vtype980, $_size978); - for ($_i982 = 0; $_i982 < $_size978; ++$_i982) + $_size977 = 0; + $_ktype978 = 0; + $_vtype979 = 0; + $xfer += $input->readMapBegin($_ktype978, $_vtype979, $_size977); + for ($_i981 = 0; $_i981 < $_size977; ++$_i981) { - $key983 = ''; - $val984 = ''; - $xfer += $input->readString($key983); - $xfer += $input->readString($val984); - $this->part_vals[$key983] = $val984; + $key982 = ''; + $val983 = ''; + $xfer += $input->readString($key982); + $xfer += $input->readString($val983); + $this->part_vals[$key982] = $val983; } $xfer += $input->readMapEnd(); } else { @@ -30188,10 +30188,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter985 => $viter986) + foreach ($this->part_vals as $kiter984 => $viter985) { - $xfer += $output->writeString($kiter985); - $xfer += $output->writeString($viter986); + $xfer += $output->writeString($kiter984); + $xfer += $output->writeString($viter985); } } $output->writeMapEnd(); @@ -31665,15 +31665,15 @@ class ThriftHiveMetastore_get_indexes_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; - $elem992 = new \metastore\Index(); - $xfer += $elem992->read($input); - $this->success []= $elem992; + $elem991 = null; + $elem991 = new \metastore\Index(); + $xfer += $elem991->read($input); + $this->success []= $elem991; } $xfer += $input->readListEnd(); } else { @@ -31717,9 +31717,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter993) + foreach ($this->success as $iter992) { - $xfer += $iter993->write($output); + $xfer += $iter992->write($output); } } $output->writeListEnd(); @@ -31926,14 +31926,14 @@ class ThriftHiveMetastore_get_index_names_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 { @@ -31969,9 +31969,9 @@ class ThriftHiveMetastore_get_index_names_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(); @@ -35865,14 +35865,14 @@ class ThriftHiveMetastore_get_functions_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 { @@ -35908,9 +35908,9 @@ class ThriftHiveMetastore_get_functions_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(); @@ -36779,14 +36779,14 @@ class ThriftHiveMetastore_get_role_names_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; - $xfer += $input->readString($elem1013); - $this->success []= $elem1013; + $elem1012 = null; + $xfer += $input->readString($elem1012); + $this->success []= $elem1012; } $xfer += $input->readListEnd(); } else { @@ -36822,9 +36822,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1014) + foreach ($this->success as $iter1013) { - $xfer += $output->writeString($iter1014); + $xfer += $output->writeString($iter1013); } } $output->writeListEnd(); @@ -37515,15 +37515,15 @@ class ThriftHiveMetastore_list_roles_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem1020 = new \metastore\Role(); - $xfer += $elem1020->read($input); - $this->success []= $elem1020; + $elem1019 = null; + $elem1019 = new \metastore\Role(); + $xfer += $elem1019->read($input); + $this->success []= $elem1019; } $xfer += $input->readListEnd(); } else { @@ -37559,9 +37559,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1021) + foreach ($this->success as $iter1020) { - $xfer += $iter1021->write($output); + $xfer += $iter1020->write($output); } } $output->writeListEnd(); @@ -38223,14 +38223,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = 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; - $xfer += $input->readString($elem1027); - $this->group_names []= $elem1027; + $elem1026 = null; + $xfer += $input->readString($elem1026); + $this->group_names []= $elem1026; } $xfer += $input->readListEnd(); } else { @@ -38271,9 +38271,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1028) + foreach ($this->group_names as $iter1027) { - $xfer += $output->writeString($iter1028); + $xfer += $output->writeString($iter1027); } } $output->writeListEnd(); @@ -38581,15 +38581,15 @@ class ThriftHiveMetastore_list_privileges_result { case 0: if ($ftype == TType::LST) { $this->success = 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; - $elem1034 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem1034->read($input); - $this->success []= $elem1034; + $elem1033 = null; + $elem1033 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem1033->read($input); + $this->success []= $elem1033; } $xfer += $input->readListEnd(); } else { @@ -38625,9 +38625,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1035) + foreach ($this->success as $iter1034) { - $xfer += $iter1035->write($output); + $xfer += $iter1034->write($output); } } $output->writeListEnd(); @@ -39259,14 +39259,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = 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->group_names []= $elem1041; + $elem1040 = null; + $xfer += $input->readString($elem1040); + $this->group_names []= $elem1040; } $xfer += $input->readListEnd(); } else { @@ -39299,9 +39299,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1042) + foreach ($this->group_names as $iter1041) { - $xfer += $output->writeString($iter1042); + $xfer += $output->writeString($iter1041); } } $output->writeListEnd(); @@ -39377,14 +39377,14 @@ class ThriftHiveMetastore_set_ugi_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 { @@ -39420,9 +39420,9 @@ class ThriftHiveMetastore_set_ugi_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(); @@ -40539,14 +40539,14 @@ class ThriftHiveMetastore_get_all_token_identifiers_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 { @@ -40574,9 +40574,9 @@ class ThriftHiveMetastore_get_all_token_identifiers_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(); @@ -41215,14 +41215,14 @@ class ThriftHiveMetastore_get_master_keys_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1057 = 0; - $_etype1060 = 0; - $xfer += $input->readListBegin($_etype1060, $_size1057); - for ($_i1061 = 0; $_i1061 < $_size1057; ++$_i1061) + $_size1056 = 0; + $_etype1059 = 0; + $xfer += $input->readListBegin($_etype1059, $_size1056); + for ($_i1060 = 0; $_i1060 < $_size1056; ++$_i1060) { - $elem1062 = null; - $xfer += $input->readString($elem1062); - $this->success []= $elem1062; + $elem1061 = null; + $xfer += $input->readString($elem1061); + $this->success []= $elem1061; } $xfer += $input->readListEnd(); } else { @@ -41250,9 +41250,9 @@ class ThriftHiveMetastore_get_master_keys_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1063) + foreach ($this->success as $iter1062) { - $xfer += $output->writeString($iter1063); + $xfer += $output->writeString($iter1062); } } $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 12d98c5..970038d 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; + s = "select txn_id, txn_state from TXNS where txn_id <= " + hwm + " order by txn_id"; 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 2df88fd..6e0070b 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); @@ -55,7 +55,8 @@ public static ValidTxnList createValidReadTxnList(GetOpenTxnsResponse txns, long * doesn't make sense for Snapshot Isolation. Of course for Read Committed, the list should * inlude the latest committed set.*/ 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) { @@ -63,10 +64,10 @@ public static ValidTxnList createValidReadTxnList(GetOpenTxnsResponse txns, long 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); } } @@ -97,7 +98,9 @@ public static ValidTxnList createValidCompactTxnList(GetOpenTxnsInfoResponse txn exceptions = Arrays.copyOf(exceptions, i); } highWater = minOpenTxn == Long.MAX_VALUE ? highWater : minOpenTxn - 1; - return new ValidCompactorTxnList(exceptions, highWater); + BitSet bitSet = new BitSet(exceptions.length); + bitSet.set(0, bitSet.length()); // for ValidCompactorTxnList, everything in exceptions are aborted + return new ValidCompactorTxnList(exceptions, bitSet, highWater); } /** diff --git metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestValidCompactorTxnList.java metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestValidCompactorTxnList.java index 79ccc6b..ab5f0e4 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestValidCompactorTxnList.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/txn/TestValidCompactorTxnList.java @@ -22,52 +22,64 @@ import org.junit.Assert; import org.junit.Test; +import java.util.BitSet; + public class TestValidCompactorTxnList { @Test public void minTxnHigh() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{3, 4}, 2); + BitSet bitSet = new BitSet(2); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{3, 4}, bitSet, 2); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); } @Test public void maxTxnLow() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{13, 14}, 12); + BitSet bitSet = new BitSet(2); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{13, 14}, bitSet, 12); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.ALL, rsp); } @Test public void minTxnHighNoExceptions() { - ValidTxnList txns = new ValidCompactorTxnList(new long[0], 5); + ValidTxnList txns = new ValidCompactorTxnList(new long[0], new BitSet(), 5); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); } @Test public void maxTxnLowNoExceptions() { - ValidTxnList txns = new ValidCompactorTxnList(new long[0], 15); + ValidTxnList txns = new ValidCompactorTxnList(new long[0], new BitSet(), 15); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.ALL, rsp); } @Test public void exceptionsAllBelow() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{3, 6}, 3); + BitSet bitSet = new BitSet(2); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{3, 6}, bitSet, 3); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); } @Test public void exceptionsInMidst() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{8}, 7); + BitSet bitSet = new BitSet(1); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{8}, bitSet, 7); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); } @Test public void exceptionsAbveHighWaterMark() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{8, 11, 17, 29}, 15); + BitSet bitSet = new BitSet(4); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{8, 11, 17, 29}, bitSet, 15); Assert.assertArrayEquals("", new long[]{8, 11}, txns.getInvalidTransactions()); ValidTxnList.RangeResponse rsp = txns.isTxnRangeValid(7, 9); Assert.assertEquals(ValidTxnList.RangeResponse.ALL, rsp); @@ -77,17 +89,19 @@ public void exceptionsAbveHighWaterMark() { @Test public void writeToString() { - ValidTxnList txns = new ValidCompactorTxnList(new long[]{9, 7, 10, Long.MAX_VALUE}, 8); - Assert.assertEquals("8:" + Long.MAX_VALUE + ":7", txns.writeToString()); + BitSet bitSet = new BitSet(4); + bitSet.set(0, bitSet.length()); + ValidTxnList txns = new ValidCompactorTxnList(new long[]{9, 7, 10, Long.MAX_VALUE}, bitSet, 8); + Assert.assertEquals("8:" + Long.MAX_VALUE + ":7:", txns.writeToString()); txns = new ValidCompactorTxnList(); - Assert.assertEquals(Long.toString(Long.MAX_VALUE) + ":" + Long.MAX_VALUE + ":", txns.writeToString()); - txns = new ValidCompactorTxnList(new long[0], 23); - Assert.assertEquals("23:" + Long.MAX_VALUE + ":", txns.writeToString()); + Assert.assertEquals(Long.toString(Long.MAX_VALUE) + ":" + Long.MAX_VALUE + "::", txns.writeToString()); + txns = new ValidCompactorTxnList(new long[0], new BitSet(), 23); + Assert.assertEquals("23:" + Long.MAX_VALUE + "::", txns.writeToString()); } @Test public void readFromString() { - ValidCompactorTxnList txns = new ValidCompactorTxnList("37:" + Long.MAX_VALUE + ":7:9:10"); + ValidCompactorTxnList txns = new ValidCompactorTxnList("37:" + Long.MAX_VALUE + "::7,9,10"); Assert.assertEquals(37L, txns.getHighWatermark()); Assert.assertEquals(Long.MAX_VALUE, txns.getMinOpenTxn()); Assert.assertArrayEquals(new long[]{7L, 9L, 10L}, txns.getInvalidTransactions()); @@ -96,4 +110,27 @@ public void readFromString() { Assert.assertEquals(Long.MAX_VALUE, txns.getMinOpenTxn()); Assert.assertEquals(0, txns.getInvalidTransactions().length); } + + @Test + public void testAbortedTxn() throws Exception { + ValidCompactorTxnList txnList = new ValidCompactorTxnList("5:4::1,2,3"); + Assert.assertEquals(5L, txnList.getHighWatermark()); + Assert.assertEquals(4, txnList.getMinOpenTxn()); + Assert.assertArrayEquals(new long[]{1L, 2L, 3L}, txnList.getInvalidTransactions()); + } + + @Test + public void testAbortedRange() throws Exception { + ValidCompactorTxnList txnList = new ValidCompactorTxnList("11:4::5,6,7,8"); + ValidTxnList.RangeResponse rsp = txnList.isTxnRangeAborted(1L, 3L); + Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); + rsp = txnList.isTxnRangeAborted(9L, 10L); + Assert.assertEquals(ValidTxnList.RangeResponse.NONE, rsp); + rsp = txnList.isTxnRangeAborted(6L, 7L); + Assert.assertEquals(ValidTxnList.RangeResponse.ALL, rsp); + rsp = txnList.isTxnRangeAborted(4L, 6L); + Assert.assertEquals(ValidTxnList.RangeResponse.SOME, rsp); + rsp = txnList.isTxnRangeAborted(6L, 13L); + Assert.assertEquals(ValidTxnList.RangeResponse.SOME, rsp); + } } 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);