diff --git a/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java b/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java index 39d97fc782..2a8eecafaf 100644 --- a/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java +++ b/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java @@ -69,6 +69,9 @@ import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent; +import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; +import org.apache.hadoop.hive.metastore.events.CommitTxnEvent; +import org.apache.hadoop.hive.metastore.events.AbortTxnEvent; import org.apache.hadoop.hive.metastore.events.ListenerEvent; import org.apache.hadoop.hive.metastore.messaging.EventMessage.EventType; import org.apache.hadoop.hive.metastore.messaging.MessageFactory; @@ -471,6 +474,35 @@ public void onInsert(InsertEvent insertEvent) throws MetaException { process(event, insertEvent); } + @Override + public void onOpenTxn(OpenTxnEvent openTxnEvent) throws MetaException { + NotificationEvent event = + new NotificationEvent(0, now(), EventType.OPEN_TXN.toString(), msgFactory.buildOpenTxnMessage( + openTxnEvent.getTxnIdItr()) + .toString()); + process(event, openTxnEvent); + } + + @Override + public void onCommitTxn(CommitTxnEvent commitTxnEvent) throws MetaException { + NotificationEvent event = + new NotificationEvent(0, now(), EventType.COMMIT_TXN.toString(), msgFactory.buildCommitTxnMessage( + commitTxnEvent.getTxnId()) + .toString()); + + process(event, commitTxnEvent); + } + + @Override + public void onAbortTxn(AbortTxnEvent abortTxnEvent) throws MetaException { + NotificationEvent event = + new NotificationEvent(0, now(), EventType.ABORT_TXN.toString(), msgFactory.buildAbortTxnMessage( + abortTxnEvent.getTxnId()) + .toString()); + + process(event, abortTxnEvent); + } + /** * @param partSetDoneEvent * @throws MetaException diff --git a/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/TestDbNotificationListener.java b/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/TestDbNotificationListener.java index 7aadf18eb4..5bf4953530 100644 --- a/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/TestDbNotificationListener.java +++ b/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/TestDbNotificationListener.java @@ -76,6 +76,9 @@ import org.apache.hadoop.hive.metastore.events.DropPartitionEvent; import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; +import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; +import org.apache.hadoop.hive.metastore.events.CommitTxnEvent; +import org.apache.hadoop.hive.metastore.events.AbortTxnEvent; import org.apache.hadoop.hive.metastore.events.ListenerEvent; import org.apache.hadoop.hive.metastore.messaging.AddPartitionMessage; import org.apache.hadoop.hive.metastore.messaging.AlterIndexMessage; @@ -229,6 +232,18 @@ public void onDropFunction (DropFunctionEvent fnEvent) throws MetaException { public void onInsert(InsertEvent insertEvent) throws MetaException { pushEventId(EventType.INSERT, insertEvent); } + + public void onOpenTxn(OpenTxnEvent openTxnEvent) throws MetaException { + pushEventId(EventType.OPEN_TXN, openTxnEvent); + } + + public void onCommitTxn(CommitTxnEvent commitTxnEvent) throws MetaException { + pushEventId(EventType.COMMIT_TXN, commitTxnEvent); + } + + public void onAbortTxn(AbortTxnEvent abortTxnEvent) throws MetaException { + pushEventId(EventType.ABORT_TXN, abortTxnEvent); + } } @SuppressWarnings("rawtypes") diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java index 41c89b1cd3..afd3ec2964 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java @@ -3550,6 +3550,18 @@ public void testRecycleFileDropTempTable() throws IOException { assertTrue(fileCount == fileCountAfter); } + @Test + public void testOpenTxnRelication() throws IOException { + String name = testName.getMethodName(); + String dbName = createDB(name, driver); + advanceDumpDir(); + Tuple bootstrap = bootstrapLoadAndVerify(dbName, "default1"); + run("CREATE TABLE " + dbName + ".acid(a int) PARTITIONED BY (load_date date) CLUSTERED BY(a) INTO 3 BUCKETS STORED AS ORC TBLPROPERTIES ('transactional'='true')", driver); + bootstrap = incrementalLoadAndVerify(dbName,bootstrap.lastReplId,"default1"); + run("REPL STATUS " + dbName + "_dupe", driverMirror); + verifyResults(new String[] {bootstrap.lastReplId}, driverMirror); + } + private NotificationEvent createDummyEvent(String dbname, String tblname, long evid) { MessageFactory msgFactory = MessageFactory.getInstance(); Table t = new Table(); diff --git a/metastore/scripts/upgrade/derby/050-HIVE-18679.derby.sql b/metastore/scripts/upgrade/derby/050-HIVE-18679.derby.sql new file mode 100644 index 0000000000..5e07ee5b28 --- /dev/null +++ b/metastore/scripts/upgrade/derby/050-HIVE-18679.derby.sql @@ -0,0 +1,6 @@ +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); diff --git a/metastore/scripts/upgrade/derby/051-HIVE-18679.derby.sql b/metastore/scripts/upgrade/derby/051-HIVE-18679.derby.sql new file mode 100644 index 0000000000..400894aa14 --- /dev/null +++ b/metastore/scripts/upgrade/derby/051-HIVE-18679.derby.sql @@ -0,0 +1,7 @@ + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); diff --git a/metastore/scripts/upgrade/derby/hive-txn-schema-3.0.0.derby.sql b/metastore/scripts/upgrade/derby/hive-txn-schema-3.0.0.derby.sql index 2033bdcec7..8ffbe19311 100644 --- a/metastore/scripts/upgrade/derby/hive-txn-schema-3.0.0.derby.sql +++ b/metastore/scripts/upgrade/derby/hive-txn-schema-3.0.0.derby.sql @@ -154,3 +154,10 @@ CREATE TABLE WRITE_SET ( WS_COMMIT_ID bigint NOT NULL, WS_OPERATION_TYPE char(1) NOT NULL ); + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); \ No newline at end of file diff --git a/metastore/scripts/upgrade/derby/upgrade-2.3.0-to-3.0.0.derby.sql b/metastore/scripts/upgrade/derby/upgrade-2.3.0-to-3.0.0.derby.sql index 55b89e77d2..ac92fad892 100644 --- a/metastore/scripts/upgrade/derby/upgrade-2.3.0-to-3.0.0.derby.sql +++ b/metastore/scripts/upgrade/derby/upgrade-2.3.0-to-3.0.0.derby.sql @@ -8,5 +8,6 @@ RUN '046-HIVE-17566.derby.sql'; RUN '048-HIVE-14498.derby.sql'; RUN '049-HIVE-18489.derby.sql'; RUN '050-HIVE-18192.derby.sql'; +RUN '051-HIVE-18679.derby.sql'; UPDATE "APP".VERSION SET SCHEMA_VERSION='3.0.0', VERSION_COMMENT='Hive release version 3.0.0' where VER_ID=1; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnTask.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnTask.java new file mode 100644 index 0000000000..4ebde269d6 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnTask.java @@ -0,0 +1,78 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec; + +import org.apache.hadoop.hive.ql.DriverContext; +import org.apache.hadoop.hive.ql.plan.api.StageType; +import org.apache.hadoop.util.StringUtils; +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; + +public class ReplTxnTask extends Task { + + private static final long serialVersionUID = 1L; + + public ReplTxnTask() { + super(); + } + + @Override + public int execute(DriverContext driverContext) { + if (Utilities.FILE_OP_LOGGER.isTraceEnabled()) { + Utilities.FILE_OP_LOGGER.trace("Executing ReplTxnTask for " + work.getTxnIds()); + } + + try { + if (work.getOperationType() == ReplTxnWork.OperationType.REPL_OPEN_TXN) { + List txnIdsItr = driverContext.getCtx().getHiveTxnManager() + .replOpenTxn(work.getReplPolicy(), work.getTxnIds(), work.getNumTxns()); + for (int i = 0; i < txnIdsItr.size(); i++) { + LOG.info( + "Replayed OpenTxn Event for policy " + work.getReplPolicy() + " with srcTxn " + work + .getTxnId(i) + " and target txn id " + txnIdsItr.get(i)); + } + } else if (work.getOperationType() == ReplTxnWork.OperationType.REPL_COMMI_TXN) { + driverContext.getCtx().getHiveTxnManager().replCommitTxn(work.getReplPolicy(), work.getTxnId(0)); + LOG.info("Replayed CommitTxn Event for policy " + work.getReplPolicy() + + " with srcTxn " + work.getTxnId(0) + " and target txn id " + work.getTxnId(0)); + } else if (work.getOperationType() == ReplTxnWork.OperationType.REPL_ABORT_TXN) { + driverContext.getCtx().getHiveTxnManager().replRollbackTxn(work.getReplPolicy(), work.getTxnId(0)); + LOG.info("Replayed AbortTxn Event for policy " + work.getReplPolicy() + " with srcTxn " + work.getTxnId(0)); + } + return 0; + } catch (Exception e) { + console.printError("Failed with exception " + e.getMessage(), "\n" + + StringUtils.stringifyException(e)); + setException(e); + return 1; + } + } + + @Override + public StageType getType() { + return StageType.MOVE; // TODO: Need to check the stage for open txn. + } + + @Override + public String getName() { + return "OPEN_TRANSACTION"; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnWork.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnWork.java new file mode 100644 index 0000000000..2046bff9f2 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/ReplTxnWork.java @@ -0,0 +1,103 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.exec; + +import java.io.Serializable; + +import com.google.common.collect.Lists; +import org.apache.hadoop.hive.ql.plan.Explain; +import org.apache.hadoop.hive.ql.plan.Explain.Level; +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; + +@Explain(displayName = "Replication Transaction", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class ReplTxnWork implements Serializable { + private static final long serialVersionUID = 1L; + private String dbName; + private String tableName; + private List txnIds; + + public enum OperationType { + REPL_OPEN_TXN("REPL_OPEN_TXN"), + REPL_ABORT_TXN("REPL_ABORT_TXN"), + REPL_COMMI_TXN("REPL_COMMI_TXN"); + + String type = null; + OperationType(String type) { + this.type = type; + } + + @Override + public String toString(){ + return type; + } + } + + OperationType operation; + + public ReplTxnWork(String dbName, String tableName, Iterator txnIdsItr, OperationType type) { + this.txnIds = Lists.newArrayList(txnIdsItr); + this.dbName = dbName; + this.tableName = tableName; + this.operation = type; + } + + public ReplTxnWork(String dbName, String tableName, Long txnId, OperationType type) { + this.txnIds = Lists.newArrayList(); + this.txnIds.add(txnId); + this.dbName = dbName; + this.tableName = tableName; + this.operation = type; + } + + public Iterator getTxnIds() { + return txnIds.iterator(); + } + + public Long getTxnId(int idx) { + return txnIds.get(idx); + } + + public int getNumTxns() { + return txnIds.size(); + } + + public String getDbName() { + return dbName; + } + + public String getTableName() { + return tableName; + } + + public String getReplPolicy() { + if (dbName == null) { + return null; + } else if (tableName == null) { + return dbName.toLowerCase() + ".*"; + } else { + return dbName.toLowerCase() + "." + tableName.toLowerCase(); + } + } + + public OperationType getOperationType() { + return operation; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/TaskFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/TaskFactory.java index d049c37ff6..e832f51634 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/TaskFactory.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/TaskFactory.java @@ -111,6 +111,7 @@ public TaskTuple(Class workClass, Class> taskClass) { taskvec.add(new TaskTuple<>(ReplLoadWork.class, ReplLoadTask.class)); taskvec.add(new TaskTuple<>(ReplStateLogWork.class, ReplStateLogTask.class)); taskvec.add(new TaskTuple(ExportWork.class, ExportTask.class)); + taskvec.add(new TaskTuple(ReplTxnWork.class, ReplTxnTask.class)); } private static ThreadLocal tid = new ThreadLocal() { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java index 683aa954cf..9d65ce9d55 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DbTxnManager.java @@ -62,6 +62,11 @@ Licensed to the Apache Software Foundation (ASF) under one import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; + /** * An implementation of HiveTxnManager that stores the transactions in the metastore database. * There should be 1 instance o {@link DbTxnManager} per {@link org.apache.hadoop.hive.ql.session.SessionState} @@ -202,6 +207,15 @@ void setHiveConf(HiveConf conf) { } } + @Override + public List replOpenTxn(String replPolicy, Iterator srcTxnIds, int numTxns) throws LockException { + try { + return getMS().replOpenTxn(replPolicy, srcTxnIds, numTxns); + } catch (TException e) { + throw new LockException(e, ErrorMsg.METASTORE_COMMUNICATION_FAILED); + } + } + @Override public long openTxn(Context ctx, String user) throws LockException { return openTxn(ctx, user, 0); @@ -590,6 +604,22 @@ public void releaseLocks(List hiveLocks) throws LockException { } } + @Override + public void replCommitTxn(String replPolicy, long srcTxnId) throws LockException { + try { + getMS().commitTxn(srcTxnId, replPolicy); + } catch (NoSuchTxnException e) { + LOG.error("Metastore could not find " + JavaUtils.txnIdToString(srcTxnId)); + throw new LockException(e, ErrorMsg.TXN_NO_SUCH_TRANSACTION, JavaUtils.txnIdToString(srcTxnId)); + } catch (TxnAbortedException e) { + LockException le = new LockException(e, ErrorMsg.TXN_ABORTED, JavaUtils.txnIdToString(srcTxnId), e.getMessage()); + LOG.error(le.getMessage()); + throw le; + } catch (TException e) { + throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), e); + } + } + @Override public void commitTxn() throws LockException { if (!isTxnOpen()) { @@ -617,6 +647,21 @@ public void commitTxn() throws LockException { tableWriteIds.clear(); } } + @Override + public void replRollbackTxn(String replPolicy, long srcTxnId) throws LockException { + try { + getMS().rollbackTxn(srcTxnId, replPolicy); + } catch (NoSuchTxnException e) { + LOG.error("Metastore could not find " + JavaUtils.txnIdToString(srcTxnId)); + throw new LockException(e, ErrorMsg.TXN_NO_SUCH_TRANSACTION, JavaUtils.txnIdToString(srcTxnId)); + } catch (TxnAbortedException e) { + LockException le = new LockException(e, ErrorMsg.TXN_ABORTED, JavaUtils.txnIdToString(srcTxnId), e.getMessage()); + LOG.error(le.getMessage()); + throw le; + } catch (TException e) { + throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), e); + } + } @Override public void rollbackTxn() throws LockException { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java index 7413074be1..26e2de6486 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java @@ -55,6 +55,11 @@ public long openTxn(Context ctx, String user) throws LockException { // No-op return 0L; } + @Override + public List replOpenTxn(String replPolicy, Iterator srcTxnIds, int numTxns) throws LockException { + return null; + } + @Override public boolean isTxnOpen() { return false; @@ -208,11 +213,21 @@ public void commitTxn() throws LockException { // No-op } + @Override + public void replCommitTxn(String replPolicy, long srcTxnId) throws LockException { + // No-op + } + @Override public void rollbackTxn() throws LockException { // No-op } + @Override + public void replRollbackTxn(String replPolicy, long srcTxnId) throws LockException { + // No-op + } + @Override public void heartbeat() throws LockException { // No-op diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManager.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManager.java index 0db2a2c3ed..41f0b38fcf 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManager.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManager.java @@ -29,6 +29,9 @@ import org.apache.hadoop.hive.ql.plan.UnlockDatabaseDesc; import org.apache.hadoop.hive.ql.plan.UnlockTableDesc; +import com.google.common.collect.Lists; + +import java.util.Iterator; import java.util.List; /** @@ -47,6 +50,32 @@ */ long openTxn(Context ctx, String user) throws LockException; + /** + * Open a new transaction in target cluster. + * @param replPolicy Replication policy to uniquely identify the source cluster. + * @param srcTxnIds The ids of the transaction at the source cluster + * @param numTxns The number of txns in the iterator + * @return The new transaction id. + * @throws LockException in case of failure to start the trasnaction. + */ + List replOpenTxn(String replPolicy, Iterator srcTxnIds, int numTxns) throws LockException ; + + /** + * Commit the transaction in target cluster. + * @param replPolicy Replication policy to uniquely identify the source cluster. + * @param srcTxnId The id of the transaction at the source cluster + * @throws LockException in case of failure to start the trasnaction. + */ + void replCommitTxn(String replPolicy, long srcTxnId) throws LockException ; + + /** + * Abort the transaction in target cluster. + * @param replPolicy Replication policy to uniquely identify the source cluster. + * @param srcTxnId The id of the transaction at the source cluster + * @throws LockException in case of failure to start the trasnaction. + */ + void replRollbackTxn(String replPolicy, long srcTxnId) throws LockException ; + /** * Get the lock manager. This must be used rather than instantiating an * instance of the lock manager directly as the transaction manager will diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManagerImpl.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManagerImpl.java index c8cafa2a68..55845e8a68 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManagerImpl.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveTxnManagerImpl.java @@ -38,6 +38,10 @@ import org.apache.hadoop.hive.ql.plan.LockTableDesc; import org.apache.hadoop.hive.ql.plan.UnlockDatabaseDesc; import org.apache.hadoop.hive.ql.plan.UnlockTableDesc; +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; /** * An implementation HiveTxnManager that includes internal methods that all diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java index 1c6b793e11..fa7c48d76d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java @@ -409,10 +409,10 @@ private static ImportTableDesc getBaseCreateTableDescFromTable(String dbName, Task copyTask = null; if (replicationSpec.isInReplicationScope()) { - if (isSourceMm || isAcid(writeId)) { + /*if (isSourceMm || isAcid(writeId)) { // Note: this is replication gap, not MM gap... Repl V2 is not ready yet. throw new RuntimeException("Replicating MM and ACID tables is not supported"); - } + }*/ copyTask = ReplCopyTask.getLoadCopyTask(replicationSpec, dataPath, destPath, x.getConf()); } else { CopyWork cw = new CopyWork(dataPath, destPath, false); @@ -506,10 +506,10 @@ private static boolean isAcid(Long writeId) { Task copyTask = null; if (replicationSpec.isInReplicationScope()) { - if (isSourceMm || isAcid(writeId)) { + /*if (isSourceMm || isAcid(writeId)) { // Note: this is replication gap, not MM gap... Repl V2 is not ready yet. throw new RuntimeException("Replicating MM and ACID tables is not supported"); - } + }*/ copyTask = ReplCopyTask.getLoadCopyTask( replicationSpec, new Path(srcLocation), destPath, x.getConf()); } else { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/DumpType.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/DumpType.java index c69ecc9405..5fab0d2ebf 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/DumpType.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/DumpType.java @@ -37,6 +37,9 @@ import org.apache.hadoop.hive.ql.parse.repl.load.message.TableHandler; import org.apache.hadoop.hive.ql.parse.repl.load.message.TruncatePartitionHandler; import org.apache.hadoop.hive.ql.parse.repl.load.message.TruncateTableHandler; +import org.apache.hadoop.hive.ql.parse.repl.load.message.OpenTxnHandler; +import org.apache.hadoop.hive.ql.parse.repl.load.message.CommitTxnHandler; +import org.apache.hadoop.hive.ql.parse.repl.load.message.AbortTxnHandler; public enum DumpType { @@ -183,6 +186,24 @@ public MessageHandler handler() { public MessageHandler handler() { return new DropDatabaseHandler(); } + }, + EVENT_OPEN_TXN("EVENT_OPEN_TXN") { + @Override + public MessageHandler handler() { + return new OpenTxnHandler(); + } + }, + EVENT_COMMIT_TXN("EVENT_COMMIT_TXN") { + @Override + public MessageHandler handler() { + return new CommitTxnHandler(); + } + }, + EVENT_ABORT_TXN("EVENT_ABORT_TXN") { + @Override + public MessageHandler handler() { + return new AbortTxnHandler(); + } }; String type = null; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/AbortTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/AbortTxnHandler.java new file mode 100644 index 0000000000..b9a5d2145c --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/AbortTxnHandler.java @@ -0,0 +1,42 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.dump.events; + +import org.apache.hadoop.hive.metastore.api.NotificationEvent; +import org.apache.hadoop.hive.ql.parse.repl.DumpType; +import org.apache.hadoop.hive.ql.parse.repl.load.DumpMetaData; + +class AbortTxnHandler extends AbstractEventHandler { + + AbortTxnHandler(NotificationEvent event) { + super(event); + } + + @Override + public void handle(Context withinContext) throws Exception { + LOG.info("Processing#{} ABORT_TXN message : {}", fromEventId(), event.getMessage()); + DumpMetaData dmd = withinContext.createDmd(this); + dmd.setPayload(event.getMessage()); + dmd.write(); + } + + @Override + public DumpType dumpType() { + return DumpType.EVENT_ABORT_TXN; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/CommitTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/CommitTxnHandler.java new file mode 100644 index 0000000000..a3747f1e86 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/CommitTxnHandler.java @@ -0,0 +1,42 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.dump.events; + +import org.apache.hadoop.hive.metastore.api.NotificationEvent; +import org.apache.hadoop.hive.ql.parse.repl.DumpType; +import org.apache.hadoop.hive.ql.parse.repl.load.DumpMetaData; + +class CommitTxnHandler extends AbstractEventHandler { + + CommitTxnHandler(NotificationEvent event) { + super(event); + } + + @Override + public void handle(Context withinContext) throws Exception { + LOG.info("Processing#{} COMMIT_TXN message : {}", fromEventId(), event.getMessage()); + DumpMetaData dmd = withinContext.createDmd(this); + dmd.setPayload(event.getMessage()); + dmd.write(); + } + + @Override + public DumpType dumpType() { + return DumpType.EVENT_COMMIT_TXN; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/EventHandlerFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/EventHandlerFactory.java index 9955246ff8..10ff21c430 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/EventHandlerFactory.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/EventHandlerFactory.java @@ -50,6 +50,9 @@ private EventHandlerFactory() { register(MessageFactory.DROP_CONSTRAINT_EVENT, DropConstraintHandler.class); register(MessageFactory.CREATE_DATABASE_EVENT, CreateDatabaseHandler.class); register(MessageFactory.DROP_DATABASE_EVENT, DropDatabaseHandler.class); + register(MessageFactory.OPEN_TXN_EVENT, OpenTxnHandler.class); + register(MessageFactory.COMMIT_TXN_EVENT, CommitTxnHandler.class); + register(MessageFactory.ABORT_TXN_EVENT, AbortTxnHandler.class); } static void register(String event, Class handlerClazz) { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/OpenTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/OpenTxnHandler.java new file mode 100644 index 0000000000..507c452309 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/dump/events/OpenTxnHandler.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.dump.events; + +import org.apache.hadoop.hive.metastore.api.NotificationEvent; + +import org.apache.hadoop.hive.ql.parse.repl.DumpType; + +import org.apache.hadoop.hive.ql.parse.repl.load.DumpMetaData; + +class OpenTxnHandler extends AbstractEventHandler { + + OpenTxnHandler(NotificationEvent event) { + super(event); + } + + @Override + public void handle(Context withinContext) throws Exception { + LOG.info("Processing#{} OPEN_TXN message : {}", fromEventId(), event.getMessage()); + DumpMetaData dmd = withinContext.createDmd(this); + dmd.setPayload(event.getMessage()); + dmd.write(); + } + + @Override + public DumpType dumpType() { + return DumpType.EVENT_OPEN_TXN; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/AbortTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/AbortTxnHandler.java new file mode 100644 index 0000000000..9b74a7f427 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/AbortTxnHandler.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.load.message; + +import org.apache.hadoop.hive.metastore.messaging.AbortTxnMessage; +import org.apache.hadoop.hive.ql.exec.ReplTxnWork; +import org.apache.hadoop.hive.ql.exec.Task; +import org.apache.hadoop.hive.ql.exec.TaskFactory; +import org.apache.hadoop.hive.ql.parse.SemanticException; + +import java.io.Serializable; +import java.util.Collections; +import java.util.List; + +public class AbortTxnHandler extends AbstractMessageHandler { + @Override + public List> handle(Context context) + throws SemanticException { + AbortTxnMessage msg = deserializer.getAbortTxnMessage(context.dmd.getPayload()); + + Task abortTxnTask = TaskFactory.get( + new ReplTxnWork(context.dbName, context.tableName, msg.getTxnId(),ReplTxnWork.OperationType.REPL_ABORT_TXN), + context.hiveConf + ); + updatedMetadata.set(context.dmd.getEventTo().toString(), context.dbName, context.tableName, null); + context.log.debug("Added Abort txn task : {}", abortTxnTask.getId()); + return Collections.singletonList(abortTxnTask); + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/CommitTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/CommitTxnHandler.java new file mode 100644 index 0000000000..ca4ff49400 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/CommitTxnHandler.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.load.message; + +import org.apache.hadoop.hive.metastore.messaging.CommitTxnMessage; +import org.apache.hadoop.hive.ql.exec.ReplTxnWork; +import org.apache.hadoop.hive.ql.exec.Task; +import org.apache.hadoop.hive.ql.exec.TaskFactory; +import org.apache.hadoop.hive.ql.parse.SemanticException; + +import java.io.Serializable; +import java.util.Collections; +import java.util.List; + +public class CommitTxnHandler extends AbstractMessageHandler { + @Override + public List> handle(Context context) + throws SemanticException { + CommitTxnMessage msg = deserializer.getCommitTxnMessage(context.dmd.getPayload()); + + Task commitTxnTask = TaskFactory.get( + new ReplTxnWork(context.dbName, context.tableName, msg.getTxnId(), + ReplTxnWork.OperationType.REPL_COMMI_TXN), context.hiveConf + ); + updatedMetadata.set(context.dmd.getEventTo().toString(), context.dbName, context.tableName, null); + context.log.debug("Added Commit txn task : {}", commitTxnTask.getId()); + return Collections.singletonList(commitTxnTask); + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/OpenTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/OpenTxnHandler.java new file mode 100644 index 0000000000..47beb27900 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/load/message/OpenTxnHandler.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse.repl.load.message; + +import org.apache.hadoop.hive.metastore.messaging.OpenTxnMessage; +import org.apache.hadoop.hive.ql.exec.ReplTxnWork; +import org.apache.hadoop.hive.ql.exec.Task; +import org.apache.hadoop.hive.ql.exec.TaskFactory; +import org.apache.hadoop.hive.ql.parse.SemanticException; + +import java.io.Serializable; +import java.util.Collections; +import java.util.List; + +public class OpenTxnHandler extends AbstractMessageHandler { + @Override + public List> handle(Context context) + throws SemanticException { + OpenTxnMessage msg = deserializer.getOpenTxnMessage(context.dmd.getPayload()); + + Task openTxnTask = TaskFactory.get( + new ReplTxnWork(context.dbName, context.tableName, msg.getTxnIdItr(), ReplTxnWork.OperationType.REPL_OPEN_TXN), + context.hiveConf + ); + updatedMetadata.set(context.dmd.getEventTo().toString(), context.dbName, context.tableName, null); + context.log.debug("Added Open txn task : {}", openTxnTask.getId()); + return Collections.singletonList(openTxnTask); + } +} diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 921cba12b3..ebd4aa029b 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-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 _size1091; - ::apache::thrift::protocol::TType _etype1094; - xfer += iprot->readListBegin(_etype1094, _size1091); - this->success.resize(_size1091); - uint32_t _i1095; - for (_i1095 = 0; _i1095 < _size1091; ++_i1095) + uint32_t _size1101; + ::apache::thrift::protocol::TType _etype1104; + xfer += iprot->readListBegin(_etype1104, _size1101); + this->success.resize(_size1101); + uint32_t _i1105; + for (_i1105 = 0; _i1105 < _size1101; ++_i1105) { - xfer += iprot->readString(this->success[_i1095]); + xfer += iprot->readString(this->success[_i1105]); } 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 _iter1096; - for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) + std::vector ::const_iterator _iter1106; + for (_iter1106 = this->success.begin(); _iter1106 != this->success.end(); ++_iter1106) { - xfer += oprot->writeString((*_iter1096)); + xfer += oprot->writeString((*_iter1106)); } 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 _size1097; - ::apache::thrift::protocol::TType _etype1100; - xfer += iprot->readListBegin(_etype1100, _size1097); - (*(this->success)).resize(_size1097); - uint32_t _i1101; - for (_i1101 = 0; _i1101 < _size1097; ++_i1101) + uint32_t _size1107; + ::apache::thrift::protocol::TType _etype1110; + xfer += iprot->readListBegin(_etype1110, _size1107); + (*(this->success)).resize(_size1107); + uint32_t _i1111; + for (_i1111 = 0; _i1111 < _size1107; ++_i1111) { - xfer += iprot->readString((*(this->success))[_i1101]); + xfer += iprot->readString((*(this->success))[_i1111]); } 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 _size1102; - ::apache::thrift::protocol::TType _etype1105; - xfer += iprot->readListBegin(_etype1105, _size1102); - this->success.resize(_size1102); - uint32_t _i1106; - for (_i1106 = 0; _i1106 < _size1102; ++_i1106) + uint32_t _size1112; + ::apache::thrift::protocol::TType _etype1115; + xfer += iprot->readListBegin(_etype1115, _size1112); + this->success.resize(_size1112); + uint32_t _i1116; + for (_i1116 = 0; _i1116 < _size1112; ++_i1116) { - xfer += iprot->readString(this->success[_i1106]); + xfer += iprot->readString(this->success[_i1116]); } 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 _iter1107; - for (_iter1107 = this->success.begin(); _iter1107 != this->success.end(); ++_iter1107) + std::vector ::const_iterator _iter1117; + for (_iter1117 = this->success.begin(); _iter1117 != this->success.end(); ++_iter1117) { - xfer += oprot->writeString((*_iter1107)); + xfer += oprot->writeString((*_iter1117)); } 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 _size1108; - ::apache::thrift::protocol::TType _etype1111; - xfer += iprot->readListBegin(_etype1111, _size1108); - (*(this->success)).resize(_size1108); - uint32_t _i1112; - for (_i1112 = 0; _i1112 < _size1108; ++_i1112) + uint32_t _size1118; + ::apache::thrift::protocol::TType _etype1121; + xfer += iprot->readListBegin(_etype1121, _size1118); + (*(this->success)).resize(_size1118); + uint32_t _i1122; + for (_i1122 = 0; _i1122 < _size1118; ++_i1122) { - xfer += iprot->readString((*(this->success))[_i1112]); + xfer += iprot->readString((*(this->success))[_i1122]); } 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 _size1113; - ::apache::thrift::protocol::TType _ktype1114; - ::apache::thrift::protocol::TType _vtype1115; - xfer += iprot->readMapBegin(_ktype1114, _vtype1115, _size1113); - uint32_t _i1117; - for (_i1117 = 0; _i1117 < _size1113; ++_i1117) + uint32_t _size1123; + ::apache::thrift::protocol::TType _ktype1124; + ::apache::thrift::protocol::TType _vtype1125; + xfer += iprot->readMapBegin(_ktype1124, _vtype1125, _size1123); + uint32_t _i1127; + for (_i1127 = 0; _i1127 < _size1123; ++_i1127) { - std::string _key1118; - xfer += iprot->readString(_key1118); - Type& _val1119 = this->success[_key1118]; - xfer += _val1119.read(iprot); + std::string _key1128; + xfer += iprot->readString(_key1128); + Type& _val1129 = this->success[_key1128]; + xfer += _val1129.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 _iter1120; - for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) + std::map ::const_iterator _iter1130; + for (_iter1130 = this->success.begin(); _iter1130 != this->success.end(); ++_iter1130) { - xfer += oprot->writeString(_iter1120->first); - xfer += _iter1120->second.write(oprot); + xfer += oprot->writeString(_iter1130->first); + xfer += _iter1130->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 _size1121; - ::apache::thrift::protocol::TType _ktype1122; - ::apache::thrift::protocol::TType _vtype1123; - xfer += iprot->readMapBegin(_ktype1122, _vtype1123, _size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + uint32_t _size1131; + ::apache::thrift::protocol::TType _ktype1132; + ::apache::thrift::protocol::TType _vtype1133; + xfer += iprot->readMapBegin(_ktype1132, _vtype1133, _size1131); + uint32_t _i1135; + for (_i1135 = 0; _i1135 < _size1131; ++_i1135) { - std::string _key1126; - xfer += iprot->readString(_key1126); - Type& _val1127 = (*(this->success))[_key1126]; - xfer += _val1127.read(iprot); + std::string _key1136; + xfer += iprot->readString(_key1136); + Type& _val1137 = (*(this->success))[_key1136]; + xfer += _val1137.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 _size1128; - ::apache::thrift::protocol::TType _etype1131; - xfer += iprot->readListBegin(_etype1131, _size1128); - this->success.resize(_size1128); - uint32_t _i1132; - for (_i1132 = 0; _i1132 < _size1128; ++_i1132) + uint32_t _size1138; + ::apache::thrift::protocol::TType _etype1141; + xfer += iprot->readListBegin(_etype1141, _size1138); + this->success.resize(_size1138); + uint32_t _i1142; + for (_i1142 = 0; _i1142 < _size1138; ++_i1142) { - xfer += this->success[_i1132].read(iprot); + xfer += this->success[_i1142].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 _iter1133; - for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) + std::vector ::const_iterator _iter1143; + for (_iter1143 = this->success.begin(); _iter1143 != this->success.end(); ++_iter1143) { - xfer += (*_iter1133).write(oprot); + xfer += (*_iter1143).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 _size1134; - ::apache::thrift::protocol::TType _etype1137; - xfer += iprot->readListBegin(_etype1137, _size1134); - (*(this->success)).resize(_size1134); - uint32_t _i1138; - for (_i1138 = 0; _i1138 < _size1134; ++_i1138) + uint32_t _size1144; + ::apache::thrift::protocol::TType _etype1147; + xfer += iprot->readListBegin(_etype1147, _size1144); + (*(this->success)).resize(_size1144); + uint32_t _i1148; + for (_i1148 = 0; _i1148 < _size1144; ++_i1148) { - xfer += (*(this->success))[_i1138].read(iprot); + xfer += (*(this->success))[_i1148].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 _size1139; - ::apache::thrift::protocol::TType _etype1142; - xfer += iprot->readListBegin(_etype1142, _size1139); - this->success.resize(_size1139); - uint32_t _i1143; - for (_i1143 = 0; _i1143 < _size1139; ++_i1143) + uint32_t _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[_i1143].read(iprot); + xfer += this->success[_i1153].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 _iter1144; - for (_iter1144 = this->success.begin(); _iter1144 != this->success.end(); ++_iter1144) + std::vector ::const_iterator _iter1154; + for (_iter1154 = this->success.begin(); _iter1154 != this->success.end(); ++_iter1154) { - xfer += (*_iter1144).write(oprot); + xfer += (*_iter1154).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 _size1145; - ::apache::thrift::protocol::TType _etype1148; - xfer += iprot->readListBegin(_etype1148, _size1145); - (*(this->success)).resize(_size1145); - uint32_t _i1149; - for (_i1149 = 0; _i1149 < _size1145; ++_i1149) + uint32_t _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))[_i1149].read(iprot); + xfer += (*(this->success))[_i1159].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 _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 _size1160; + ::apache::thrift::protocol::TType _etype1163; + xfer += iprot->readListBegin(_etype1163, _size1160); + this->success.resize(_size1160); + uint32_t _i1164; + for (_i1164 = 0; _i1164 < _size1160; ++_i1164) { - xfer += this->success[_i1154].read(iprot); + xfer += this->success[_i1164].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 _iter1155; - for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) + std::vector ::const_iterator _iter1165; + for (_iter1165 = this->success.begin(); _iter1165 != this->success.end(); ++_iter1165) { - xfer += (*_iter1155).write(oprot); + xfer += (*_iter1165).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 _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 _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + (*(this->success)).resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += (*(this->success))[_i1160].read(iprot); + xfer += (*(this->success))[_i1170].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 _size1161; - ::apache::thrift::protocol::TType _etype1164; - xfer += iprot->readListBegin(_etype1164, _size1161); - this->success.resize(_size1161); - uint32_t _i1165; - for (_i1165 = 0; _i1165 < _size1161; ++_i1165) + uint32_t _size1171; + ::apache::thrift::protocol::TType _etype1174; + xfer += iprot->readListBegin(_etype1174, _size1171); + this->success.resize(_size1171); + uint32_t _i1175; + for (_i1175 = 0; _i1175 < _size1171; ++_i1175) { - xfer += this->success[_i1165].read(iprot); + xfer += this->success[_i1175].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 _iter1166; - for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166) + std::vector ::const_iterator _iter1176; + for (_iter1176 = this->success.begin(); _iter1176 != this->success.end(); ++_iter1176) { - xfer += (*_iter1166).write(oprot); + xfer += (*_iter1176).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 _size1167; - ::apache::thrift::protocol::TType _etype1170; - xfer += iprot->readListBegin(_etype1170, _size1167); - (*(this->success)).resize(_size1167); - uint32_t _i1171; - for (_i1171 = 0; _i1171 < _size1167; ++_i1171) + uint32_t _size1177; + ::apache::thrift::protocol::TType _etype1180; + xfer += iprot->readListBegin(_etype1180, _size1177); + (*(this->success)).resize(_size1177); + uint32_t _i1181; + for (_i1181 = 0; _i1181 < _size1177; ++_i1181) { - xfer += (*(this->success))[_i1171].read(iprot); + xfer += (*(this->success))[_i1181].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 _size1172; - ::apache::thrift::protocol::TType _etype1175; - xfer += iprot->readListBegin(_etype1175, _size1172); - this->primaryKeys.resize(_size1172); - uint32_t _i1176; - for (_i1176 = 0; _i1176 < _size1172; ++_i1176) + uint32_t _size1182; + ::apache::thrift::protocol::TType _etype1185; + xfer += iprot->readListBegin(_etype1185, _size1182); + this->primaryKeys.resize(_size1182); + uint32_t _i1186; + for (_i1186 = 0; _i1186 < _size1182; ++_i1186) { - xfer += this->primaryKeys[_i1176].read(iprot); + xfer += this->primaryKeys[_i1186].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 _size1177; - ::apache::thrift::protocol::TType _etype1180; - xfer += iprot->readListBegin(_etype1180, _size1177); - this->foreignKeys.resize(_size1177); - uint32_t _i1181; - for (_i1181 = 0; _i1181 < _size1177; ++_i1181) + uint32_t _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->foreignKeys.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += this->foreignKeys[_i1181].read(iprot); + xfer += this->foreignKeys[_i1191].read(iprot); } xfer += iprot->readListEnd(); } @@ -4558,14 +4558,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1182; - ::apache::thrift::protocol::TType _etype1185; - xfer += iprot->readListBegin(_etype1185, _size1182); - this->uniqueConstraints.resize(_size1182); - uint32_t _i1186; - for (_i1186 = 0; _i1186 < _size1182; ++_i1186) + uint32_t _size1192; + ::apache::thrift::protocol::TType _etype1195; + xfer += iprot->readListBegin(_etype1195, _size1192); + this->uniqueConstraints.resize(_size1192); + uint32_t _i1196; + for (_i1196 = 0; _i1196 < _size1192; ++_i1196) { - xfer += this->uniqueConstraints[_i1186].read(iprot); + xfer += this->uniqueConstraints[_i1196].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,14 +4578,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1187; - ::apache::thrift::protocol::TType _etype1190; - xfer += iprot->readListBegin(_etype1190, _size1187); - this->notNullConstraints.resize(_size1187); - uint32_t _i1191; - for (_i1191 = 0; _i1191 < _size1187; ++_i1191) + uint32_t _size1197; + ::apache::thrift::protocol::TType _etype1200; + xfer += iprot->readListBegin(_etype1200, _size1197); + this->notNullConstraints.resize(_size1197); + uint32_t _i1201; + for (_i1201 = 0; _i1201 < _size1197; ++_i1201) { - xfer += this->notNullConstraints[_i1191].read(iprot); + xfer += this->notNullConstraints[_i1201].read(iprot); } xfer += iprot->readListEnd(); } @@ -4618,10 +4618,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 _iter1192; - for (_iter1192 = this->primaryKeys.begin(); _iter1192 != this->primaryKeys.end(); ++_iter1192) + std::vector ::const_iterator _iter1202; + for (_iter1202 = this->primaryKeys.begin(); _iter1202 != this->primaryKeys.end(); ++_iter1202) { - xfer += (*_iter1192).write(oprot); + xfer += (*_iter1202).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4630,10 +4630,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 _iter1193; - for (_iter1193 = this->foreignKeys.begin(); _iter1193 != this->foreignKeys.end(); ++_iter1193) + std::vector ::const_iterator _iter1203; + for (_iter1203 = this->foreignKeys.begin(); _iter1203 != this->foreignKeys.end(); ++_iter1203) { - xfer += (*_iter1193).write(oprot); + xfer += (*_iter1203).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4642,10 +4642,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter1194; - for (_iter1194 = this->uniqueConstraints.begin(); _iter1194 != this->uniqueConstraints.end(); ++_iter1194) + std::vector ::const_iterator _iter1204; + for (_iter1204 = this->uniqueConstraints.begin(); _iter1204 != this->uniqueConstraints.end(); ++_iter1204) { - xfer += (*_iter1194).write(oprot); + xfer += (*_iter1204).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4654,10 +4654,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter1195; - for (_iter1195 = this->notNullConstraints.begin(); _iter1195 != this->notNullConstraints.end(); ++_iter1195) + std::vector ::const_iterator _iter1205; + for (_iter1205 = this->notNullConstraints.begin(); _iter1205 != this->notNullConstraints.end(); ++_iter1205) { - xfer += (*_iter1195).write(oprot); + xfer += (*_iter1205).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4685,10 +4685,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 _iter1196; - for (_iter1196 = (*(this->primaryKeys)).begin(); _iter1196 != (*(this->primaryKeys)).end(); ++_iter1196) + std::vector ::const_iterator _iter1206; + for (_iter1206 = (*(this->primaryKeys)).begin(); _iter1206 != (*(this->primaryKeys)).end(); ++_iter1206) { - xfer += (*_iter1196).write(oprot); + xfer += (*_iter1206).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4697,10 +4697,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 _iter1197; - for (_iter1197 = (*(this->foreignKeys)).begin(); _iter1197 != (*(this->foreignKeys)).end(); ++_iter1197) + std::vector ::const_iterator _iter1207; + for (_iter1207 = (*(this->foreignKeys)).begin(); _iter1207 != (*(this->foreignKeys)).end(); ++_iter1207) { - xfer += (*_iter1197).write(oprot); + xfer += (*_iter1207).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4709,10 +4709,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); - std::vector ::const_iterator _iter1198; - for (_iter1198 = (*(this->uniqueConstraints)).begin(); _iter1198 != (*(this->uniqueConstraints)).end(); ++_iter1198) + std::vector ::const_iterator _iter1208; + for (_iter1208 = (*(this->uniqueConstraints)).begin(); _iter1208 != (*(this->uniqueConstraints)).end(); ++_iter1208) { - xfer += (*_iter1198).write(oprot); + xfer += (*_iter1208).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4721,10 +4721,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); - std::vector ::const_iterator _iter1199; - for (_iter1199 = (*(this->notNullConstraints)).begin(); _iter1199 != (*(this->notNullConstraints)).end(); ++_iter1199) + std::vector ::const_iterator _iter1209; + for (_iter1209 = (*(this->notNullConstraints)).begin(); _iter1209 != (*(this->notNullConstraints)).end(); ++_iter1209) { - xfer += (*_iter1199).write(oprot); + xfer += (*_iter1209).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6478,14 +6478,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1200; - ::apache::thrift::protocol::TType _etype1203; - xfer += iprot->readListBegin(_etype1203, _size1200); - this->partNames.resize(_size1200); - uint32_t _i1204; - for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + uint32_t _size1210; + ::apache::thrift::protocol::TType _etype1213; + xfer += iprot->readListBegin(_etype1213, _size1210); + this->partNames.resize(_size1210); + uint32_t _i1214; + for (_i1214 = 0; _i1214 < _size1210; ++_i1214) { - xfer += iprot->readString(this->partNames[_i1204]); + xfer += iprot->readString(this->partNames[_i1214]); } xfer += iprot->readListEnd(); } @@ -6522,10 +6522,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 _iter1205; - for (_iter1205 = this->partNames.begin(); _iter1205 != this->partNames.end(); ++_iter1205) + std::vector ::const_iterator _iter1215; + for (_iter1215 = this->partNames.begin(); _iter1215 != this->partNames.end(); ++_iter1215) { - xfer += oprot->writeString((*_iter1205)); + xfer += oprot->writeString((*_iter1215)); } xfer += oprot->writeListEnd(); } @@ -6557,10 +6557,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 _iter1206; - for (_iter1206 = (*(this->partNames)).begin(); _iter1206 != (*(this->partNames)).end(); ++_iter1206) + std::vector ::const_iterator _iter1216; + for (_iter1216 = (*(this->partNames)).begin(); _iter1216 != (*(this->partNames)).end(); ++_iter1216) { - xfer += oprot->writeString((*_iter1206)); + xfer += oprot->writeString((*_iter1216)); } xfer += oprot->writeListEnd(); } @@ -6804,14 +6804,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1207; - ::apache::thrift::protocol::TType _etype1210; - xfer += iprot->readListBegin(_etype1210, _size1207); - this->success.resize(_size1207); - uint32_t _i1211; - for (_i1211 = 0; _i1211 < _size1207; ++_i1211) + uint32_t _size1217; + ::apache::thrift::protocol::TType _etype1220; + xfer += iprot->readListBegin(_etype1220, _size1217); + this->success.resize(_size1217); + uint32_t _i1221; + for (_i1221 = 0; _i1221 < _size1217; ++_i1221) { - xfer += iprot->readString(this->success[_i1211]); + xfer += iprot->readString(this->success[_i1221]); } xfer += iprot->readListEnd(); } @@ -6850,10 +6850,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 _iter1212; - for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212) + std::vector ::const_iterator _iter1222; + for (_iter1222 = this->success.begin(); _iter1222 != this->success.end(); ++_iter1222) { - xfer += oprot->writeString((*_iter1212)); + xfer += oprot->writeString((*_iter1222)); } xfer += oprot->writeListEnd(); } @@ -6898,14 +6898,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1213; - ::apache::thrift::protocol::TType _etype1216; - xfer += iprot->readListBegin(_etype1216, _size1213); - (*(this->success)).resize(_size1213); - uint32_t _i1217; - for (_i1217 = 0; _i1217 < _size1213; ++_i1217) + uint32_t _size1223; + ::apache::thrift::protocol::TType _etype1226; + xfer += iprot->readListBegin(_etype1226, _size1223); + (*(this->success)).resize(_size1223); + uint32_t _i1227; + for (_i1227 = 0; _i1227 < _size1223; ++_i1227) { - xfer += iprot->readString((*(this->success))[_i1217]); + xfer += iprot->readString((*(this->success))[_i1227]); } xfer += iprot->readListEnd(); } @@ -7075,14 +7075,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 _size1218; - ::apache::thrift::protocol::TType _etype1221; - xfer += iprot->readListBegin(_etype1221, _size1218); - this->success.resize(_size1218); - uint32_t _i1222; - for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + uint32_t _size1228; + ::apache::thrift::protocol::TType _etype1231; + xfer += iprot->readListBegin(_etype1231, _size1228); + this->success.resize(_size1228); + uint32_t _i1232; + for (_i1232 = 0; _i1232 < _size1228; ++_i1232) { - xfer += iprot->readString(this->success[_i1222]); + xfer += iprot->readString(this->success[_i1232]); } xfer += iprot->readListEnd(); } @@ -7121,10 +7121,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 _iter1223; - for (_iter1223 = this->success.begin(); _iter1223 != this->success.end(); ++_iter1223) + std::vector ::const_iterator _iter1233; + for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) { - xfer += oprot->writeString((*_iter1223)); + xfer += oprot->writeString((*_iter1233)); } xfer += oprot->writeListEnd(); } @@ -7169,14 +7169,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1224; - ::apache::thrift::protocol::TType _etype1227; - xfer += iprot->readListBegin(_etype1227, _size1224); - (*(this->success)).resize(_size1224); - uint32_t _i1228; - for (_i1228 = 0; _i1228 < _size1224; ++_i1228) + uint32_t _size1234; + ::apache::thrift::protocol::TType _etype1237; + xfer += iprot->readListBegin(_etype1237, _size1234); + (*(this->success)).resize(_size1234); + uint32_t _i1238; + for (_i1238 = 0; _i1238 < _size1234; ++_i1238) { - xfer += iprot->readString((*(this->success))[_i1228]); + xfer += iprot->readString((*(this->success))[_i1238]); } xfer += iprot->readListEnd(); } @@ -7314,14 +7314,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1229; - ::apache::thrift::protocol::TType _etype1232; - xfer += iprot->readListBegin(_etype1232, _size1229); - this->success.resize(_size1229); - uint32_t _i1233; - for (_i1233 = 0; _i1233 < _size1229; ++_i1233) + 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) { - xfer += iprot->readString(this->success[_i1233]); + xfer += iprot->readString(this->success[_i1243]); } xfer += iprot->readListEnd(); } @@ -7360,10 +7360,10 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write( 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 _iter1234; - for (_iter1234 = this->success.begin(); _iter1234 != this->success.end(); ++_iter1234) + std::vector ::const_iterator _iter1244; + for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) { - xfer += oprot->writeString((*_iter1234)); + xfer += oprot->writeString((*_iter1244)); } xfer += oprot->writeListEnd(); } @@ -7408,14 +7408,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1235; - ::apache::thrift::protocol::TType _etype1238; - xfer += iprot->readListBegin(_etype1238, _size1235); - (*(this->success)).resize(_size1235); - uint32_t _i1239; - for (_i1239 = 0; _i1239 < _size1235; ++_i1239) + uint32_t _size1245; + ::apache::thrift::protocol::TType _etype1248; + xfer += iprot->readListBegin(_etype1248, _size1245); + (*(this->success)).resize(_size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - xfer += iprot->readString((*(this->success))[_i1239]); + xfer += iprot->readString((*(this->success))[_i1249]); } xfer += iprot->readListEnd(); } @@ -7490,14 +7490,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 _size1240; - ::apache::thrift::protocol::TType _etype1243; - xfer += iprot->readListBegin(_etype1243, _size1240); - this->tbl_types.resize(_size1240); - uint32_t _i1244; - for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->tbl_types.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString(this->tbl_types[_i1244]); + xfer += iprot->readString(this->tbl_types[_i1254]); } xfer += iprot->readListEnd(); } @@ -7534,10 +7534,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 _iter1245; - for (_iter1245 = this->tbl_types.begin(); _iter1245 != this->tbl_types.end(); ++_iter1245) + std::vector ::const_iterator _iter1255; + for (_iter1255 = this->tbl_types.begin(); _iter1255 != this->tbl_types.end(); ++_iter1255) { - xfer += oprot->writeString((*_iter1245)); + xfer += oprot->writeString((*_iter1255)); } xfer += oprot->writeListEnd(); } @@ -7569,10 +7569,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 _iter1246; - for (_iter1246 = (*(this->tbl_types)).begin(); _iter1246 != (*(this->tbl_types)).end(); ++_iter1246) + std::vector ::const_iterator _iter1256; + for (_iter1256 = (*(this->tbl_types)).begin(); _iter1256 != (*(this->tbl_types)).end(); ++_iter1256) { - xfer += oprot->writeString((*_iter1246)); + xfer += oprot->writeString((*_iter1256)); } xfer += oprot->writeListEnd(); } @@ -7613,14 +7613,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1247; - ::apache::thrift::protocol::TType _etype1250; - xfer += iprot->readListBegin(_etype1250, _size1247); - this->success.resize(_size1247); - uint32_t _i1251; - for (_i1251 = 0; _i1251 < _size1247; ++_i1251) + uint32_t _size1257; + ::apache::thrift::protocol::TType _etype1260; + xfer += iprot->readListBegin(_etype1260, _size1257); + this->success.resize(_size1257); + uint32_t _i1261; + for (_i1261 = 0; _i1261 < _size1257; ++_i1261) { - xfer += this->success[_i1251].read(iprot); + xfer += this->success[_i1261].read(iprot); } xfer += iprot->readListEnd(); } @@ -7659,10 +7659,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 _iter1252; - for (_iter1252 = this->success.begin(); _iter1252 != this->success.end(); ++_iter1252) + std::vector ::const_iterator _iter1262; + for (_iter1262 = this->success.begin(); _iter1262 != this->success.end(); ++_iter1262) { - xfer += (*_iter1252).write(oprot); + xfer += (*_iter1262).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7707,14 +7707,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1253; - ::apache::thrift::protocol::TType _etype1256; - xfer += iprot->readListBegin(_etype1256, _size1253); - (*(this->success)).resize(_size1253); - uint32_t _i1257; - for (_i1257 = 0; _i1257 < _size1253; ++_i1257) + uint32_t _size1263; + ::apache::thrift::protocol::TType _etype1266; + xfer += iprot->readListBegin(_etype1266, _size1263); + (*(this->success)).resize(_size1263); + uint32_t _i1267; + for (_i1267 = 0; _i1267 < _size1263; ++_i1267) { - xfer += (*(this->success))[_i1257].read(iprot); + xfer += (*(this->success))[_i1267].read(iprot); } xfer += iprot->readListEnd(); } @@ -7852,14 +7852,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1258; - ::apache::thrift::protocol::TType _etype1261; - xfer += iprot->readListBegin(_etype1261, _size1258); - this->success.resize(_size1258); - uint32_t _i1262; - for (_i1262 = 0; _i1262 < _size1258; ++_i1262) + uint32_t _size1268; + ::apache::thrift::protocol::TType _etype1271; + xfer += iprot->readListBegin(_etype1271, _size1268); + this->success.resize(_size1268); + uint32_t _i1272; + for (_i1272 = 0; _i1272 < _size1268; ++_i1272) { - xfer += iprot->readString(this->success[_i1262]); + xfer += iprot->readString(this->success[_i1272]); } xfer += iprot->readListEnd(); } @@ -7898,10 +7898,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 _iter1263; - for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263) + std::vector ::const_iterator _iter1273; + for (_iter1273 = this->success.begin(); _iter1273 != this->success.end(); ++_iter1273) { - xfer += oprot->writeString((*_iter1263)); + xfer += oprot->writeString((*_iter1273)); } xfer += oprot->writeListEnd(); } @@ -7946,14 +7946,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1264; - ::apache::thrift::protocol::TType _etype1267; - xfer += iprot->readListBegin(_etype1267, _size1264); - (*(this->success)).resize(_size1264); - uint32_t _i1268; - for (_i1268 = 0; _i1268 < _size1264; ++_i1268) + uint32_t _size1274; + ::apache::thrift::protocol::TType _etype1277; + xfer += iprot->readListBegin(_etype1277, _size1274); + (*(this->success)).resize(_size1274); + uint32_t _i1278; + for (_i1278 = 0; _i1278 < _size1274; ++_i1278) { - xfer += iprot->readString((*(this->success))[_i1268]); + xfer += iprot->readString((*(this->success))[_i1278]); } xfer += iprot->readListEnd(); } @@ -8263,14 +8263,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 _size1269; - ::apache::thrift::protocol::TType _etype1272; - xfer += iprot->readListBegin(_etype1272, _size1269); - this->tbl_names.resize(_size1269); - uint32_t _i1273; - for (_i1273 = 0; _i1273 < _size1269; ++_i1273) + uint32_t _size1279; + ::apache::thrift::protocol::TType _etype1282; + xfer += iprot->readListBegin(_etype1282, _size1279); + this->tbl_names.resize(_size1279); + uint32_t _i1283; + for (_i1283 = 0; _i1283 < _size1279; ++_i1283) { - xfer += iprot->readString(this->tbl_names[_i1273]); + xfer += iprot->readString(this->tbl_names[_i1283]); } xfer += iprot->readListEnd(); } @@ -8303,10 +8303,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 _iter1274; - for (_iter1274 = this->tbl_names.begin(); _iter1274 != this->tbl_names.end(); ++_iter1274) + std::vector ::const_iterator _iter1284; + for (_iter1284 = this->tbl_names.begin(); _iter1284 != this->tbl_names.end(); ++_iter1284) { - xfer += oprot->writeString((*_iter1274)); + xfer += oprot->writeString((*_iter1284)); } xfer += oprot->writeListEnd(); } @@ -8334,10 +8334,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 _iter1275; - for (_iter1275 = (*(this->tbl_names)).begin(); _iter1275 != (*(this->tbl_names)).end(); ++_iter1275) + std::vector ::const_iterator _iter1285; + for (_iter1285 = (*(this->tbl_names)).begin(); _iter1285 != (*(this->tbl_names)).end(); ++_iter1285) { - xfer += oprot->writeString((*_iter1275)); + xfer += oprot->writeString((*_iter1285)); } xfer += oprot->writeListEnd(); } @@ -8378,14 +8378,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 _size1276; - ::apache::thrift::protocol::TType _etype1279; - xfer += iprot->readListBegin(_etype1279, _size1276); - this->success.resize(_size1276); - uint32_t _i1280; - for (_i1280 = 0; _i1280 < _size1276; ++_i1280) + uint32_t _size1286; + ::apache::thrift::protocol::TType _etype1289; + xfer += iprot->readListBegin(_etype1289, _size1286); + this->success.resize(_size1286); + uint32_t _i1290; + for (_i1290 = 0; _i1290 < _size1286; ++_i1290) { - xfer += this->success[_i1280].read(iprot); + xfer += this->success[_i1290].read(iprot); } xfer += iprot->readListEnd(); } @@ -8416,10 +8416,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 _iter1281; - for (_iter1281 = this->success.begin(); _iter1281 != this->success.end(); ++_iter1281) + std::vector
::const_iterator _iter1291; + for (_iter1291 = this->success.begin(); _iter1291 != this->success.end(); ++_iter1291) { - xfer += (*_iter1281).write(oprot); + xfer += (*_iter1291).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8460,14 +8460,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 _size1282; - ::apache::thrift::protocol::TType _etype1285; - xfer += iprot->readListBegin(_etype1285, _size1282); - (*(this->success)).resize(_size1282); - uint32_t _i1286; - for (_i1286 = 0; _i1286 < _size1282; ++_i1286) + uint32_t _size1292; + ::apache::thrift::protocol::TType _etype1295; + xfer += iprot->readListBegin(_etype1295, _size1292); + (*(this->success)).resize(_size1292); + uint32_t _i1296; + for (_i1296 = 0; _i1296 < _size1292; ++_i1296) { - xfer += (*(this->success))[_i1286].read(iprot); + xfer += (*(this->success))[_i1296].read(iprot); } xfer += iprot->readListEnd(); } @@ -9000,14 +9000,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1287; - ::apache::thrift::protocol::TType _etype1290; - xfer += iprot->readListBegin(_etype1290, _size1287); - this->tbl_names.resize(_size1287); - uint32_t _i1291; - for (_i1291 = 0; _i1291 < _size1287; ++_i1291) + uint32_t _size1297; + ::apache::thrift::protocol::TType _etype1300; + xfer += iprot->readListBegin(_etype1300, _size1297); + this->tbl_names.resize(_size1297); + uint32_t _i1301; + for (_i1301 = 0; _i1301 < _size1297; ++_i1301) { - xfer += iprot->readString(this->tbl_names[_i1291]); + xfer += iprot->readString(this->tbl_names[_i1301]); } xfer += iprot->readListEnd(); } @@ -9040,10 +9040,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::write(: 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 _iter1292; - for (_iter1292 = this->tbl_names.begin(); _iter1292 != this->tbl_names.end(); ++_iter1292) + std::vector ::const_iterator _iter1302; + for (_iter1302 = this->tbl_names.begin(); _iter1302 != this->tbl_names.end(); ++_iter1302) { - xfer += oprot->writeString((*_iter1292)); + xfer += oprot->writeString((*_iter1302)); } xfer += oprot->writeListEnd(); } @@ -9071,10 +9071,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_pargs::write( 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 _iter1293; - for (_iter1293 = (*(this->tbl_names)).begin(); _iter1293 != (*(this->tbl_names)).end(); ++_iter1293) + std::vector ::const_iterator _iter1303; + for (_iter1303 = (*(this->tbl_names)).begin(); _iter1303 != (*(this->tbl_names)).end(); ++_iter1303) { - xfer += oprot->writeString((*_iter1293)); + xfer += oprot->writeString((*_iter1303)); } xfer += oprot->writeListEnd(); } @@ -9115,17 +9115,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1294; - ::apache::thrift::protocol::TType _ktype1295; - ::apache::thrift::protocol::TType _vtype1296; - xfer += iprot->readMapBegin(_ktype1295, _vtype1296, _size1294); - uint32_t _i1298; - for (_i1298 = 0; _i1298 < _size1294; ++_i1298) + uint32_t _size1304; + ::apache::thrift::protocol::TType _ktype1305; + ::apache::thrift::protocol::TType _vtype1306; + xfer += iprot->readMapBegin(_ktype1305, _vtype1306, _size1304); + uint32_t _i1308; + for (_i1308 = 0; _i1308 < _size1304; ++_i1308) { - std::string _key1299; - xfer += iprot->readString(_key1299); - Materialization& _val1300 = this->success[_key1299]; - xfer += _val1300.read(iprot); + std::string _key1309; + xfer += iprot->readString(_key1309); + Materialization& _val1310 = this->success[_key1309]; + xfer += _val1310.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9180,11 +9180,11 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::write 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 _iter1301; - for (_iter1301 = this->success.begin(); _iter1301 != this->success.end(); ++_iter1301) + std::map ::const_iterator _iter1311; + for (_iter1311 = this->success.begin(); _iter1311 != this->success.end(); ++_iter1311) { - xfer += oprot->writeString(_iter1301->first); - xfer += _iter1301->second.write(oprot); + xfer += oprot->writeString(_iter1311->first); + xfer += _iter1311->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -9237,17 +9237,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1302; - ::apache::thrift::protocol::TType _ktype1303; - ::apache::thrift::protocol::TType _vtype1304; - xfer += iprot->readMapBegin(_ktype1303, _vtype1304, _size1302); - uint32_t _i1306; - for (_i1306 = 0; _i1306 < _size1302; ++_i1306) + uint32_t _size1312; + ::apache::thrift::protocol::TType _ktype1313; + ::apache::thrift::protocol::TType _vtype1314; + xfer += iprot->readMapBegin(_ktype1313, _vtype1314, _size1312); + uint32_t _i1316; + for (_i1316 = 0; _i1316 < _size1312; ++_i1316) { - std::string _key1307; - xfer += iprot->readString(_key1307); - Materialization& _val1308 = (*(this->success))[_key1307]; - xfer += _val1308.read(iprot); + std::string _key1317; + xfer += iprot->readString(_key1317); + Materialization& _val1318 = (*(this->success))[_key1317]; + xfer += _val1318.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9692,14 +9692,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 _size1309; - ::apache::thrift::protocol::TType _etype1312; - xfer += iprot->readListBegin(_etype1312, _size1309); - this->success.resize(_size1309); - uint32_t _i1313; - for (_i1313 = 0; _i1313 < _size1309; ++_i1313) + uint32_t _size1319; + ::apache::thrift::protocol::TType _etype1322; + xfer += iprot->readListBegin(_etype1322, _size1319); + this->success.resize(_size1319); + uint32_t _i1323; + for (_i1323 = 0; _i1323 < _size1319; ++_i1323) { - xfer += iprot->readString(this->success[_i1313]); + xfer += iprot->readString(this->success[_i1323]); } xfer += iprot->readListEnd(); } @@ -9754,10 +9754,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 _iter1314; - for (_iter1314 = this->success.begin(); _iter1314 != this->success.end(); ++_iter1314) + std::vector ::const_iterator _iter1324; + for (_iter1324 = this->success.begin(); _iter1324 != this->success.end(); ++_iter1324) { - xfer += oprot->writeString((*_iter1314)); + xfer += oprot->writeString((*_iter1324)); } xfer += oprot->writeListEnd(); } @@ -9810,14 +9810,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 _size1315; - ::apache::thrift::protocol::TType _etype1318; - xfer += iprot->readListBegin(_etype1318, _size1315); - (*(this->success)).resize(_size1315); - uint32_t _i1319; - for (_i1319 = 0; _i1319 < _size1315; ++_i1319) + uint32_t _size1325; + ::apache::thrift::protocol::TType _etype1328; + xfer += iprot->readListBegin(_etype1328, _size1325); + (*(this->success)).resize(_size1325); + uint32_t _i1329; + for (_i1329 = 0; _i1329 < _size1325; ++_i1329) { - xfer += iprot->readString((*(this->success))[_i1319]); + xfer += iprot->readString((*(this->success))[_i1329]); } xfer += iprot->readListEnd(); } @@ -11151,14 +11151,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1320; - ::apache::thrift::protocol::TType _etype1323; - xfer += iprot->readListBegin(_etype1323, _size1320); - this->new_parts.resize(_size1320); - uint32_t _i1324; - for (_i1324 = 0; _i1324 < _size1320; ++_i1324) + uint32_t _size1330; + ::apache::thrift::protocol::TType _etype1333; + xfer += iprot->readListBegin(_etype1333, _size1330); + this->new_parts.resize(_size1330); + uint32_t _i1334; + for (_i1334 = 0; _i1334 < _size1330; ++_i1334) { - xfer += this->new_parts[_i1324].read(iprot); + xfer += this->new_parts[_i1334].read(iprot); } xfer += iprot->readListEnd(); } @@ -11187,10 +11187,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 _iter1325; - for (_iter1325 = this->new_parts.begin(); _iter1325 != this->new_parts.end(); ++_iter1325) + std::vector ::const_iterator _iter1335; + for (_iter1335 = this->new_parts.begin(); _iter1335 != this->new_parts.end(); ++_iter1335) { - xfer += (*_iter1325).write(oprot); + xfer += (*_iter1335).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11214,10 +11214,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 _iter1326; - for (_iter1326 = (*(this->new_parts)).begin(); _iter1326 != (*(this->new_parts)).end(); ++_iter1326) + std::vector ::const_iterator _iter1336; + for (_iter1336 = (*(this->new_parts)).begin(); _iter1336 != (*(this->new_parts)).end(); ++_iter1336) { - xfer += (*_iter1326).write(oprot); + xfer += (*_iter1336).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11426,14 +11426,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 _size1327; - ::apache::thrift::protocol::TType _etype1330; - xfer += iprot->readListBegin(_etype1330, _size1327); - this->new_parts.resize(_size1327); - uint32_t _i1331; - for (_i1331 = 0; _i1331 < _size1327; ++_i1331) + uint32_t _size1337; + ::apache::thrift::protocol::TType _etype1340; + xfer += iprot->readListBegin(_etype1340, _size1337); + this->new_parts.resize(_size1337); + uint32_t _i1341; + for (_i1341 = 0; _i1341 < _size1337; ++_i1341) { - xfer += this->new_parts[_i1331].read(iprot); + xfer += this->new_parts[_i1341].read(iprot); } xfer += iprot->readListEnd(); } @@ -11462,10 +11462,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 _iter1332; - for (_iter1332 = this->new_parts.begin(); _iter1332 != this->new_parts.end(); ++_iter1332) + std::vector ::const_iterator _iter1342; + for (_iter1342 = this->new_parts.begin(); _iter1342 != this->new_parts.end(); ++_iter1342) { - xfer += (*_iter1332).write(oprot); + xfer += (*_iter1342).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11489,10 +11489,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 _iter1333; - for (_iter1333 = (*(this->new_parts)).begin(); _iter1333 != (*(this->new_parts)).end(); ++_iter1333) + std::vector ::const_iterator _iter1343; + for (_iter1343 = (*(this->new_parts)).begin(); _iter1343 != (*(this->new_parts)).end(); ++_iter1343) { - xfer += (*_iter1333).write(oprot); + xfer += (*_iter1343).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11717,14 +11717,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1334; - ::apache::thrift::protocol::TType _etype1337; - xfer += iprot->readListBegin(_etype1337, _size1334); - this->part_vals.resize(_size1334); - uint32_t _i1338; - for (_i1338 = 0; _i1338 < _size1334; ++_i1338) + uint32_t _size1344; + ::apache::thrift::protocol::TType _etype1347; + xfer += iprot->readListBegin(_etype1347, _size1344); + this->part_vals.resize(_size1344); + uint32_t _i1348; + for (_i1348 = 0; _i1348 < _size1344; ++_i1348) { - xfer += iprot->readString(this->part_vals[_i1338]); + xfer += iprot->readString(this->part_vals[_i1348]); } xfer += iprot->readListEnd(); } @@ -11761,10 +11761,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 _iter1339; - for (_iter1339 = this->part_vals.begin(); _iter1339 != this->part_vals.end(); ++_iter1339) + std::vector ::const_iterator _iter1349; + for (_iter1349 = this->part_vals.begin(); _iter1349 != this->part_vals.end(); ++_iter1349) { - xfer += oprot->writeString((*_iter1339)); + xfer += oprot->writeString((*_iter1349)); } xfer += oprot->writeListEnd(); } @@ -11796,10 +11796,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 _iter1340; - for (_iter1340 = (*(this->part_vals)).begin(); _iter1340 != (*(this->part_vals)).end(); ++_iter1340) + std::vector ::const_iterator _iter1350; + for (_iter1350 = (*(this->part_vals)).begin(); _iter1350 != (*(this->part_vals)).end(); ++_iter1350) { - xfer += oprot->writeString((*_iter1340)); + xfer += oprot->writeString((*_iter1350)); } xfer += oprot->writeListEnd(); } @@ -12271,14 +12271,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1341; - ::apache::thrift::protocol::TType _etype1344; - xfer += iprot->readListBegin(_etype1344, _size1341); - this->part_vals.resize(_size1341); - uint32_t _i1345; - for (_i1345 = 0; _i1345 < _size1341; ++_i1345) + uint32_t _size1351; + ::apache::thrift::protocol::TType _etype1354; + xfer += iprot->readListBegin(_etype1354, _size1351); + this->part_vals.resize(_size1351); + uint32_t _i1355; + for (_i1355 = 0; _i1355 < _size1351; ++_i1355) { - xfer += iprot->readString(this->part_vals[_i1345]); + xfer += iprot->readString(this->part_vals[_i1355]); } xfer += iprot->readListEnd(); } @@ -12323,10 +12323,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 _iter1346; - for (_iter1346 = this->part_vals.begin(); _iter1346 != this->part_vals.end(); ++_iter1346) + std::vector ::const_iterator _iter1356; + for (_iter1356 = this->part_vals.begin(); _iter1356 != this->part_vals.end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1346)); + xfer += oprot->writeString((*_iter1356)); } xfer += oprot->writeListEnd(); } @@ -12362,10 +12362,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 _iter1347; - for (_iter1347 = (*(this->part_vals)).begin(); _iter1347 != (*(this->part_vals)).end(); ++_iter1347) + std::vector ::const_iterator _iter1357; + for (_iter1357 = (*(this->part_vals)).begin(); _iter1357 != (*(this->part_vals)).end(); ++_iter1357) { - xfer += oprot->writeString((*_iter1347)); + xfer += oprot->writeString((*_iter1357)); } xfer += oprot->writeListEnd(); } @@ -13168,14 +13168,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1348; - ::apache::thrift::protocol::TType _etype1351; - xfer += iprot->readListBegin(_etype1351, _size1348); - this->part_vals.resize(_size1348); - uint32_t _i1352; - for (_i1352 = 0; _i1352 < _size1348; ++_i1352) + uint32_t _size1358; + ::apache::thrift::protocol::TType _etype1361; + xfer += iprot->readListBegin(_etype1361, _size1358); + this->part_vals.resize(_size1358); + uint32_t _i1362; + for (_i1362 = 0; _i1362 < _size1358; ++_i1362) { - xfer += iprot->readString(this->part_vals[_i1352]); + xfer += iprot->readString(this->part_vals[_i1362]); } xfer += iprot->readListEnd(); } @@ -13220,10 +13220,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 _iter1353; - for (_iter1353 = this->part_vals.begin(); _iter1353 != this->part_vals.end(); ++_iter1353) + std::vector ::const_iterator _iter1363; + for (_iter1363 = this->part_vals.begin(); _iter1363 != this->part_vals.end(); ++_iter1363) { - xfer += oprot->writeString((*_iter1353)); + xfer += oprot->writeString((*_iter1363)); } xfer += oprot->writeListEnd(); } @@ -13259,10 +13259,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 _iter1354; - for (_iter1354 = (*(this->part_vals)).begin(); _iter1354 != (*(this->part_vals)).end(); ++_iter1354) + std::vector ::const_iterator _iter1364; + for (_iter1364 = (*(this->part_vals)).begin(); _iter1364 != (*(this->part_vals)).end(); ++_iter1364) { - xfer += oprot->writeString((*_iter1354)); + xfer += oprot->writeString((*_iter1364)); } xfer += oprot->writeListEnd(); } @@ -13471,14 +13471,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1355; - ::apache::thrift::protocol::TType _etype1358; - xfer += iprot->readListBegin(_etype1358, _size1355); - this->part_vals.resize(_size1355); - uint32_t _i1359; - for (_i1359 = 0; _i1359 < _size1355; ++_i1359) + uint32_t _size1365; + ::apache::thrift::protocol::TType _etype1368; + xfer += iprot->readListBegin(_etype1368, _size1365); + this->part_vals.resize(_size1365); + uint32_t _i1369; + for (_i1369 = 0; _i1369 < _size1365; ++_i1369) { - xfer += iprot->readString(this->part_vals[_i1359]); + xfer += iprot->readString(this->part_vals[_i1369]); } xfer += iprot->readListEnd(); } @@ -13531,10 +13531,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 _iter1360; - for (_iter1360 = this->part_vals.begin(); _iter1360 != this->part_vals.end(); ++_iter1360) + std::vector ::const_iterator _iter1370; + for (_iter1370 = this->part_vals.begin(); _iter1370 != this->part_vals.end(); ++_iter1370) { - xfer += oprot->writeString((*_iter1360)); + xfer += oprot->writeString((*_iter1370)); } xfer += oprot->writeListEnd(); } @@ -13574,10 +13574,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 _iter1361; - for (_iter1361 = (*(this->part_vals)).begin(); _iter1361 != (*(this->part_vals)).end(); ++_iter1361) + std::vector ::const_iterator _iter1371; + for (_iter1371 = (*(this->part_vals)).begin(); _iter1371 != (*(this->part_vals)).end(); ++_iter1371) { - xfer += oprot->writeString((*_iter1361)); + xfer += oprot->writeString((*_iter1371)); } xfer += oprot->writeListEnd(); } @@ -14583,14 +14583,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1362; - ::apache::thrift::protocol::TType _etype1365; - xfer += iprot->readListBegin(_etype1365, _size1362); - this->part_vals.resize(_size1362); - uint32_t _i1366; - for (_i1366 = 0; _i1366 < _size1362; ++_i1366) + uint32_t _size1372; + ::apache::thrift::protocol::TType _etype1375; + xfer += iprot->readListBegin(_etype1375, _size1372); + this->part_vals.resize(_size1372); + uint32_t _i1376; + for (_i1376 = 0; _i1376 < _size1372; ++_i1376) { - xfer += iprot->readString(this->part_vals[_i1366]); + xfer += iprot->readString(this->part_vals[_i1376]); } xfer += iprot->readListEnd(); } @@ -14627,10 +14627,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 _iter1367; - for (_iter1367 = this->part_vals.begin(); _iter1367 != this->part_vals.end(); ++_iter1367) + std::vector ::const_iterator _iter1377; + for (_iter1377 = this->part_vals.begin(); _iter1377 != this->part_vals.end(); ++_iter1377) { - xfer += oprot->writeString((*_iter1367)); + xfer += oprot->writeString((*_iter1377)); } xfer += oprot->writeListEnd(); } @@ -14662,10 +14662,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 _iter1368; - for (_iter1368 = (*(this->part_vals)).begin(); _iter1368 != (*(this->part_vals)).end(); ++_iter1368) + std::vector ::const_iterator _iter1378; + for (_iter1378 = (*(this->part_vals)).begin(); _iter1378 != (*(this->part_vals)).end(); ++_iter1378) { - xfer += oprot->writeString((*_iter1368)); + xfer += oprot->writeString((*_iter1378)); } xfer += oprot->writeListEnd(); } @@ -14854,17 +14854,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1369; - ::apache::thrift::protocol::TType _ktype1370; - ::apache::thrift::protocol::TType _vtype1371; - xfer += iprot->readMapBegin(_ktype1370, _vtype1371, _size1369); - uint32_t _i1373; - for (_i1373 = 0; _i1373 < _size1369; ++_i1373) + uint32_t _size1379; + ::apache::thrift::protocol::TType _ktype1380; + ::apache::thrift::protocol::TType _vtype1381; + xfer += iprot->readMapBegin(_ktype1380, _vtype1381, _size1379); + uint32_t _i1383; + for (_i1383 = 0; _i1383 < _size1379; ++_i1383) { - std::string _key1374; - xfer += iprot->readString(_key1374); - std::string& _val1375 = this->partitionSpecs[_key1374]; - xfer += iprot->readString(_val1375); + std::string _key1384; + xfer += iprot->readString(_key1384); + std::string& _val1385 = this->partitionSpecs[_key1384]; + xfer += iprot->readString(_val1385); } xfer += iprot->readMapEnd(); } @@ -14925,11 +14925,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 _iter1376; - for (_iter1376 = this->partitionSpecs.begin(); _iter1376 != this->partitionSpecs.end(); ++_iter1376) + std::map ::const_iterator _iter1386; + for (_iter1386 = this->partitionSpecs.begin(); _iter1386 != this->partitionSpecs.end(); ++_iter1386) { - xfer += oprot->writeString(_iter1376->first); - xfer += oprot->writeString(_iter1376->second); + xfer += oprot->writeString(_iter1386->first); + xfer += oprot->writeString(_iter1386->second); } xfer += oprot->writeMapEnd(); } @@ -14969,11 +14969,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 _iter1377; - for (_iter1377 = (*(this->partitionSpecs)).begin(); _iter1377 != (*(this->partitionSpecs)).end(); ++_iter1377) + std::map ::const_iterator _iter1387; + for (_iter1387 = (*(this->partitionSpecs)).begin(); _iter1387 != (*(this->partitionSpecs)).end(); ++_iter1387) { - xfer += oprot->writeString(_iter1377->first); - xfer += oprot->writeString(_iter1377->second); + xfer += oprot->writeString(_iter1387->first); + xfer += oprot->writeString(_iter1387->second); } xfer += oprot->writeMapEnd(); } @@ -15218,17 +15218,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1378; - ::apache::thrift::protocol::TType _ktype1379; - ::apache::thrift::protocol::TType _vtype1380; - xfer += iprot->readMapBegin(_ktype1379, _vtype1380, _size1378); - uint32_t _i1382; - for (_i1382 = 0; _i1382 < _size1378; ++_i1382) + uint32_t _size1388; + ::apache::thrift::protocol::TType _ktype1389; + ::apache::thrift::protocol::TType _vtype1390; + xfer += iprot->readMapBegin(_ktype1389, _vtype1390, _size1388); + uint32_t _i1392; + for (_i1392 = 0; _i1392 < _size1388; ++_i1392) { - std::string _key1383; - xfer += iprot->readString(_key1383); - std::string& _val1384 = this->partitionSpecs[_key1383]; - xfer += iprot->readString(_val1384); + std::string _key1393; + xfer += iprot->readString(_key1393); + std::string& _val1394 = this->partitionSpecs[_key1393]; + xfer += iprot->readString(_val1394); } xfer += iprot->readMapEnd(); } @@ -15289,11 +15289,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 _iter1385; - for (_iter1385 = this->partitionSpecs.begin(); _iter1385 != this->partitionSpecs.end(); ++_iter1385) + std::map ::const_iterator _iter1395; + for (_iter1395 = this->partitionSpecs.begin(); _iter1395 != this->partitionSpecs.end(); ++_iter1395) { - xfer += oprot->writeString(_iter1385->first); - xfer += oprot->writeString(_iter1385->second); + xfer += oprot->writeString(_iter1395->first); + xfer += oprot->writeString(_iter1395->second); } xfer += oprot->writeMapEnd(); } @@ -15333,11 +15333,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 _iter1386; - for (_iter1386 = (*(this->partitionSpecs)).begin(); _iter1386 != (*(this->partitionSpecs)).end(); ++_iter1386) + std::map ::const_iterator _iter1396; + for (_iter1396 = (*(this->partitionSpecs)).begin(); _iter1396 != (*(this->partitionSpecs)).end(); ++_iter1396) { - xfer += oprot->writeString(_iter1386->first); - xfer += oprot->writeString(_iter1386->second); + xfer += oprot->writeString(_iter1396->first); + xfer += oprot->writeString(_iter1396->second); } xfer += oprot->writeMapEnd(); } @@ -15394,14 +15394,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1387; - ::apache::thrift::protocol::TType _etype1390; - xfer += iprot->readListBegin(_etype1390, _size1387); - this->success.resize(_size1387); - uint32_t _i1391; - for (_i1391 = 0; _i1391 < _size1387; ++_i1391) + uint32_t _size1397; + ::apache::thrift::protocol::TType _etype1400; + xfer += iprot->readListBegin(_etype1400, _size1397); + this->success.resize(_size1397); + uint32_t _i1401; + for (_i1401 = 0; _i1401 < _size1397; ++_i1401) { - xfer += this->success[_i1391].read(iprot); + xfer += this->success[_i1401].read(iprot); } xfer += iprot->readListEnd(); } @@ -15464,10 +15464,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 _iter1392; - for (_iter1392 = this->success.begin(); _iter1392 != this->success.end(); ++_iter1392) + std::vector ::const_iterator _iter1402; + for (_iter1402 = this->success.begin(); _iter1402 != this->success.end(); ++_iter1402) { - xfer += (*_iter1392).write(oprot); + xfer += (*_iter1402).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15524,14 +15524,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1393; - ::apache::thrift::protocol::TType _etype1396; - xfer += iprot->readListBegin(_etype1396, _size1393); - (*(this->success)).resize(_size1393); - uint32_t _i1397; - for (_i1397 = 0; _i1397 < _size1393; ++_i1397) + 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) { - xfer += (*(this->success))[_i1397].read(iprot); + xfer += (*(this->success))[_i1407].read(iprot); } xfer += iprot->readListEnd(); } @@ -15630,14 +15630,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 _size1398; - ::apache::thrift::protocol::TType _etype1401; - xfer += iprot->readListBegin(_etype1401, _size1398); - this->part_vals.resize(_size1398); - uint32_t _i1402; - for (_i1402 = 0; _i1402 < _size1398; ++_i1402) + uint32_t _size1408; + ::apache::thrift::protocol::TType _etype1411; + xfer += iprot->readListBegin(_etype1411, _size1408); + this->part_vals.resize(_size1408); + uint32_t _i1412; + for (_i1412 = 0; _i1412 < _size1408; ++_i1412) { - xfer += iprot->readString(this->part_vals[_i1402]); + xfer += iprot->readString(this->part_vals[_i1412]); } xfer += iprot->readListEnd(); } @@ -15658,14 +15658,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 _size1403; - ::apache::thrift::protocol::TType _etype1406; - xfer += iprot->readListBegin(_etype1406, _size1403); - this->group_names.resize(_size1403); - uint32_t _i1407; - for (_i1407 = 0; _i1407 < _size1403; ++_i1407) + uint32_t _size1413; + ::apache::thrift::protocol::TType _etype1416; + xfer += iprot->readListBegin(_etype1416, _size1413); + this->group_names.resize(_size1413); + uint32_t _i1417; + for (_i1417 = 0; _i1417 < _size1413; ++_i1417) { - xfer += iprot->readString(this->group_names[_i1407]); + xfer += iprot->readString(this->group_names[_i1417]); } xfer += iprot->readListEnd(); } @@ -15702,10 +15702,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 _iter1408; - for (_iter1408 = this->part_vals.begin(); _iter1408 != this->part_vals.end(); ++_iter1408) + std::vector ::const_iterator _iter1418; + for (_iter1418 = this->part_vals.begin(); _iter1418 != this->part_vals.end(); ++_iter1418) { - xfer += oprot->writeString((*_iter1408)); + xfer += oprot->writeString((*_iter1418)); } xfer += oprot->writeListEnd(); } @@ -15718,10 +15718,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 _iter1409; - for (_iter1409 = this->group_names.begin(); _iter1409 != this->group_names.end(); ++_iter1409) + std::vector ::const_iterator _iter1419; + for (_iter1419 = this->group_names.begin(); _iter1419 != this->group_names.end(); ++_iter1419) { - xfer += oprot->writeString((*_iter1409)); + xfer += oprot->writeString((*_iter1419)); } xfer += oprot->writeListEnd(); } @@ -15753,10 +15753,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 _iter1410; - for (_iter1410 = (*(this->part_vals)).begin(); _iter1410 != (*(this->part_vals)).end(); ++_iter1410) + std::vector ::const_iterator _iter1420; + for (_iter1420 = (*(this->part_vals)).begin(); _iter1420 != (*(this->part_vals)).end(); ++_iter1420) { - xfer += oprot->writeString((*_iter1410)); + xfer += oprot->writeString((*_iter1420)); } xfer += oprot->writeListEnd(); } @@ -15769,10 +15769,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 _iter1411; - for (_iter1411 = (*(this->group_names)).begin(); _iter1411 != (*(this->group_names)).end(); ++_iter1411) + std::vector ::const_iterator _iter1421; + for (_iter1421 = (*(this->group_names)).begin(); _iter1421 != (*(this->group_names)).end(); ++_iter1421) { - xfer += oprot->writeString((*_iter1411)); + xfer += oprot->writeString((*_iter1421)); } xfer += oprot->writeListEnd(); } @@ -16331,14 +16331,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1412; - ::apache::thrift::protocol::TType _etype1415; - xfer += iprot->readListBegin(_etype1415, _size1412); - this->success.resize(_size1412); - uint32_t _i1416; - for (_i1416 = 0; _i1416 < _size1412; ++_i1416) + uint32_t _size1422; + ::apache::thrift::protocol::TType _etype1425; + xfer += iprot->readListBegin(_etype1425, _size1422); + this->success.resize(_size1422); + uint32_t _i1426; + for (_i1426 = 0; _i1426 < _size1422; ++_i1426) { - xfer += this->success[_i1416].read(iprot); + xfer += this->success[_i1426].read(iprot); } xfer += iprot->readListEnd(); } @@ -16385,10 +16385,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 _iter1417; - for (_iter1417 = this->success.begin(); _iter1417 != this->success.end(); ++_iter1417) + std::vector ::const_iterator _iter1427; + for (_iter1427 = this->success.begin(); _iter1427 != this->success.end(); ++_iter1427) { - xfer += (*_iter1417).write(oprot); + xfer += (*_iter1427).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16437,14 +16437,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1418; - ::apache::thrift::protocol::TType _etype1421; - xfer += iprot->readListBegin(_etype1421, _size1418); - (*(this->success)).resize(_size1418); - uint32_t _i1422; - for (_i1422 = 0; _i1422 < _size1418; ++_i1422) + uint32_t _size1428; + ::apache::thrift::protocol::TType _etype1431; + xfer += iprot->readListBegin(_etype1431, _size1428); + (*(this->success)).resize(_size1428); + uint32_t _i1432; + for (_i1432 = 0; _i1432 < _size1428; ++_i1432) { - xfer += (*(this->success))[_i1422].read(iprot); + xfer += (*(this->success))[_i1432].read(iprot); } xfer += iprot->readListEnd(); } @@ -16543,14 +16543,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 _size1423; - ::apache::thrift::protocol::TType _etype1426; - xfer += iprot->readListBegin(_etype1426, _size1423); - this->group_names.resize(_size1423); - uint32_t _i1427; - for (_i1427 = 0; _i1427 < _size1423; ++_i1427) + uint32_t _size1433; + ::apache::thrift::protocol::TType _etype1436; + xfer += iprot->readListBegin(_etype1436, _size1433); + this->group_names.resize(_size1433); + uint32_t _i1437; + for (_i1437 = 0; _i1437 < _size1433; ++_i1437) { - xfer += iprot->readString(this->group_names[_i1427]); + xfer += iprot->readString(this->group_names[_i1437]); } xfer += iprot->readListEnd(); } @@ -16595,10 +16595,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 _iter1428; - for (_iter1428 = this->group_names.begin(); _iter1428 != this->group_names.end(); ++_iter1428) + std::vector ::const_iterator _iter1438; + for (_iter1438 = this->group_names.begin(); _iter1438 != this->group_names.end(); ++_iter1438) { - xfer += oprot->writeString((*_iter1428)); + xfer += oprot->writeString((*_iter1438)); } xfer += oprot->writeListEnd(); } @@ -16638,10 +16638,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 _iter1429; - for (_iter1429 = (*(this->group_names)).begin(); _iter1429 != (*(this->group_names)).end(); ++_iter1429) + std::vector ::const_iterator _iter1439; + for (_iter1439 = (*(this->group_names)).begin(); _iter1439 != (*(this->group_names)).end(); ++_iter1439) { - xfer += oprot->writeString((*_iter1429)); + xfer += oprot->writeString((*_iter1439)); } xfer += oprot->writeListEnd(); } @@ -16682,14 +16682,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1440; + ::apache::thrift::protocol::TType _etype1443; + xfer += iprot->readListBegin(_etype1443, _size1440); + this->success.resize(_size1440); + uint32_t _i1444; + for (_i1444 = 0; _i1444 < _size1440; ++_i1444) { - xfer += this->success[_i1434].read(iprot); + xfer += this->success[_i1444].read(iprot); } xfer += iprot->readListEnd(); } @@ -16736,10 +16736,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 _iter1435; - for (_iter1435 = this->success.begin(); _iter1435 != this->success.end(); ++_iter1435) + std::vector ::const_iterator _iter1445; + for (_iter1445 = this->success.begin(); _iter1445 != this->success.end(); ++_iter1445) { - xfer += (*_iter1435).write(oprot); + xfer += (*_iter1445).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16788,14 +16788,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1436; - ::apache::thrift::protocol::TType _etype1439; - xfer += iprot->readListBegin(_etype1439, _size1436); - (*(this->success)).resize(_size1436); - uint32_t _i1440; - for (_i1440 = 0; _i1440 < _size1436; ++_i1440) + uint32_t _size1446; + ::apache::thrift::protocol::TType _etype1449; + xfer += iprot->readListBegin(_etype1449, _size1446); + (*(this->success)).resize(_size1446); + uint32_t _i1450; + for (_i1450 = 0; _i1450 < _size1446; ++_i1450) { - xfer += (*(this->success))[_i1440].read(iprot); + xfer += (*(this->success))[_i1450].read(iprot); } xfer += iprot->readListEnd(); } @@ -16973,14 +16973,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1441; - ::apache::thrift::protocol::TType _etype1444; - xfer += iprot->readListBegin(_etype1444, _size1441); - this->success.resize(_size1441); - uint32_t _i1445; - for (_i1445 = 0; _i1445 < _size1441; ++_i1445) + uint32_t _size1451; + ::apache::thrift::protocol::TType _etype1454; + xfer += iprot->readListBegin(_etype1454, _size1451); + this->success.resize(_size1451); + uint32_t _i1455; + for (_i1455 = 0; _i1455 < _size1451; ++_i1455) { - xfer += this->success[_i1445].read(iprot); + xfer += this->success[_i1455].read(iprot); } xfer += iprot->readListEnd(); } @@ -17027,10 +17027,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 _iter1446; - for (_iter1446 = this->success.begin(); _iter1446 != this->success.end(); ++_iter1446) + std::vector ::const_iterator _iter1456; + for (_iter1456 = this->success.begin(); _iter1456 != this->success.end(); ++_iter1456) { - xfer += (*_iter1446).write(oprot); + xfer += (*_iter1456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17079,14 +17079,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1447; - ::apache::thrift::protocol::TType _etype1450; - xfer += iprot->readListBegin(_etype1450, _size1447); - (*(this->success)).resize(_size1447); - uint32_t _i1451; - for (_i1451 = 0; _i1451 < _size1447; ++_i1451) + uint32_t _size1457; + ::apache::thrift::protocol::TType _etype1460; + xfer += iprot->readListBegin(_etype1460, _size1457); + (*(this->success)).resize(_size1457); + uint32_t _i1461; + for (_i1461 = 0; _i1461 < _size1457; ++_i1461) { - xfer += (*(this->success))[_i1451].read(iprot); + xfer += (*(this->success))[_i1461].read(iprot); } xfer += iprot->readListEnd(); } @@ -17264,14 +17264,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1452; - ::apache::thrift::protocol::TType _etype1455; - xfer += iprot->readListBegin(_etype1455, _size1452); - this->success.resize(_size1452); - uint32_t _i1456; - for (_i1456 = 0; _i1456 < _size1452; ++_i1456) + uint32_t _size1462; + ::apache::thrift::protocol::TType _etype1465; + xfer += iprot->readListBegin(_etype1465, _size1462); + this->success.resize(_size1462); + uint32_t _i1466; + for (_i1466 = 0; _i1466 < _size1462; ++_i1466) { - xfer += iprot->readString(this->success[_i1456]); + xfer += iprot->readString(this->success[_i1466]); } xfer += iprot->readListEnd(); } @@ -17318,10 +17318,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 _iter1457; - for (_iter1457 = this->success.begin(); _iter1457 != this->success.end(); ++_iter1457) + std::vector ::const_iterator _iter1467; + for (_iter1467 = this->success.begin(); _iter1467 != this->success.end(); ++_iter1467) { - xfer += oprot->writeString((*_iter1457)); + xfer += oprot->writeString((*_iter1467)); } xfer += oprot->writeListEnd(); } @@ -17370,14 +17370,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1458; - ::apache::thrift::protocol::TType _etype1461; - xfer += iprot->readListBegin(_etype1461, _size1458); - (*(this->success)).resize(_size1458); - uint32_t _i1462; - for (_i1462 = 0; _i1462 < _size1458; ++_i1462) + uint32_t _size1468; + ::apache::thrift::protocol::TType _etype1471; + xfer += iprot->readListBegin(_etype1471, _size1468); + (*(this->success)).resize(_size1468); + uint32_t _i1472; + for (_i1472 = 0; _i1472 < _size1468; ++_i1472) { - xfer += iprot->readString((*(this->success))[_i1462]); + xfer += iprot->readString((*(this->success))[_i1472]); } xfer += iprot->readListEnd(); } @@ -17687,14 +17687,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 _size1463; - ::apache::thrift::protocol::TType _etype1466; - xfer += iprot->readListBegin(_etype1466, _size1463); - this->part_vals.resize(_size1463); - uint32_t _i1467; - for (_i1467 = 0; _i1467 < _size1463; ++_i1467) + uint32_t _size1473; + ::apache::thrift::protocol::TType _etype1476; + xfer += iprot->readListBegin(_etype1476, _size1473); + this->part_vals.resize(_size1473); + uint32_t _i1477; + for (_i1477 = 0; _i1477 < _size1473; ++_i1477) { - xfer += iprot->readString(this->part_vals[_i1467]); + xfer += iprot->readString(this->part_vals[_i1477]); } xfer += iprot->readListEnd(); } @@ -17739,10 +17739,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 _iter1468; - for (_iter1468 = this->part_vals.begin(); _iter1468 != this->part_vals.end(); ++_iter1468) + std::vector ::const_iterator _iter1478; + for (_iter1478 = this->part_vals.begin(); _iter1478 != this->part_vals.end(); ++_iter1478) { - xfer += oprot->writeString((*_iter1468)); + xfer += oprot->writeString((*_iter1478)); } xfer += oprot->writeListEnd(); } @@ -17778,10 +17778,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 _iter1469; - for (_iter1469 = (*(this->part_vals)).begin(); _iter1469 != (*(this->part_vals)).end(); ++_iter1469) + std::vector ::const_iterator _iter1479; + for (_iter1479 = (*(this->part_vals)).begin(); _iter1479 != (*(this->part_vals)).end(); ++_iter1479) { - xfer += oprot->writeString((*_iter1469)); + xfer += oprot->writeString((*_iter1479)); } xfer += oprot->writeListEnd(); } @@ -17826,14 +17826,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1470; - ::apache::thrift::protocol::TType _etype1473; - xfer += iprot->readListBegin(_etype1473, _size1470); - this->success.resize(_size1470); - uint32_t _i1474; - for (_i1474 = 0; _i1474 < _size1470; ++_i1474) + uint32_t _size1480; + ::apache::thrift::protocol::TType _etype1483; + xfer += iprot->readListBegin(_etype1483, _size1480); + this->success.resize(_size1480); + uint32_t _i1484; + for (_i1484 = 0; _i1484 < _size1480; ++_i1484) { - xfer += this->success[_i1474].read(iprot); + xfer += this->success[_i1484].read(iprot); } xfer += iprot->readListEnd(); } @@ -17880,10 +17880,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 _iter1475; - for (_iter1475 = this->success.begin(); _iter1475 != this->success.end(); ++_iter1475) + std::vector ::const_iterator _iter1485; + for (_iter1485 = this->success.begin(); _iter1485 != this->success.end(); ++_iter1485) { - xfer += (*_iter1475).write(oprot); + xfer += (*_iter1485).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17932,14 +17932,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1476; - ::apache::thrift::protocol::TType _etype1479; - xfer += iprot->readListBegin(_etype1479, _size1476); - (*(this->success)).resize(_size1476); - uint32_t _i1480; - for (_i1480 = 0; _i1480 < _size1476; ++_i1480) + uint32_t _size1486; + ::apache::thrift::protocol::TType _etype1489; + xfer += iprot->readListBegin(_etype1489, _size1486); + (*(this->success)).resize(_size1486); + uint32_t _i1490; + for (_i1490 = 0; _i1490 < _size1486; ++_i1490) { - xfer += (*(this->success))[_i1480].read(iprot); + xfer += (*(this->success))[_i1490].read(iprot); } xfer += iprot->readListEnd(); } @@ -18022,14 +18022,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 _size1481; - ::apache::thrift::protocol::TType _etype1484; - xfer += iprot->readListBegin(_etype1484, _size1481); - this->part_vals.resize(_size1481); - uint32_t _i1485; - for (_i1485 = 0; _i1485 < _size1481; ++_i1485) + uint32_t _size1491; + ::apache::thrift::protocol::TType _etype1494; + xfer += iprot->readListBegin(_etype1494, _size1491); + this->part_vals.resize(_size1491); + uint32_t _i1495; + for (_i1495 = 0; _i1495 < _size1491; ++_i1495) { - xfer += iprot->readString(this->part_vals[_i1485]); + xfer += iprot->readString(this->part_vals[_i1495]); } xfer += iprot->readListEnd(); } @@ -18058,14 +18058,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 _size1486; - ::apache::thrift::protocol::TType _etype1489; - xfer += iprot->readListBegin(_etype1489, _size1486); - this->group_names.resize(_size1486); - uint32_t _i1490; - for (_i1490 = 0; _i1490 < _size1486; ++_i1490) + uint32_t _size1496; + ::apache::thrift::protocol::TType _etype1499; + xfer += iprot->readListBegin(_etype1499, _size1496); + this->group_names.resize(_size1496); + uint32_t _i1500; + for (_i1500 = 0; _i1500 < _size1496; ++_i1500) { - xfer += iprot->readString(this->group_names[_i1490]); + xfer += iprot->readString(this->group_names[_i1500]); } xfer += iprot->readListEnd(); } @@ -18102,10 +18102,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 _iter1491; - for (_iter1491 = this->part_vals.begin(); _iter1491 != this->part_vals.end(); ++_iter1491) + std::vector ::const_iterator _iter1501; + for (_iter1501 = this->part_vals.begin(); _iter1501 != this->part_vals.end(); ++_iter1501) { - xfer += oprot->writeString((*_iter1491)); + xfer += oprot->writeString((*_iter1501)); } xfer += oprot->writeListEnd(); } @@ -18122,10 +18122,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 _iter1492; - for (_iter1492 = this->group_names.begin(); _iter1492 != this->group_names.end(); ++_iter1492) + std::vector ::const_iterator _iter1502; + for (_iter1502 = this->group_names.begin(); _iter1502 != this->group_names.end(); ++_iter1502) { - xfer += oprot->writeString((*_iter1492)); + xfer += oprot->writeString((*_iter1502)); } xfer += oprot->writeListEnd(); } @@ -18157,10 +18157,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 _iter1493; - for (_iter1493 = (*(this->part_vals)).begin(); _iter1493 != (*(this->part_vals)).end(); ++_iter1493) + std::vector ::const_iterator _iter1503; + for (_iter1503 = (*(this->part_vals)).begin(); _iter1503 != (*(this->part_vals)).end(); ++_iter1503) { - xfer += oprot->writeString((*_iter1493)); + xfer += oprot->writeString((*_iter1503)); } xfer += oprot->writeListEnd(); } @@ -18177,10 +18177,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 _iter1494; - for (_iter1494 = (*(this->group_names)).begin(); _iter1494 != (*(this->group_names)).end(); ++_iter1494) + std::vector ::const_iterator _iter1504; + for (_iter1504 = (*(this->group_names)).begin(); _iter1504 != (*(this->group_names)).end(); ++_iter1504) { - xfer += oprot->writeString((*_iter1494)); + xfer += oprot->writeString((*_iter1504)); } xfer += oprot->writeListEnd(); } @@ -18221,14 +18221,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1495; - ::apache::thrift::protocol::TType _etype1498; - xfer += iprot->readListBegin(_etype1498, _size1495); - this->success.resize(_size1495); - uint32_t _i1499; - for (_i1499 = 0; _i1499 < _size1495; ++_i1499) + uint32_t _size1505; + ::apache::thrift::protocol::TType _etype1508; + xfer += iprot->readListBegin(_etype1508, _size1505); + this->success.resize(_size1505); + uint32_t _i1509; + for (_i1509 = 0; _i1509 < _size1505; ++_i1509) { - xfer += this->success[_i1499].read(iprot); + xfer += this->success[_i1509].read(iprot); } xfer += iprot->readListEnd(); } @@ -18275,10 +18275,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 _iter1500; - for (_iter1500 = this->success.begin(); _iter1500 != this->success.end(); ++_iter1500) + std::vector ::const_iterator _iter1510; + for (_iter1510 = this->success.begin(); _iter1510 != this->success.end(); ++_iter1510) { - xfer += (*_iter1500).write(oprot); + xfer += (*_iter1510).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18327,14 +18327,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1501; - ::apache::thrift::protocol::TType _etype1504; - xfer += iprot->readListBegin(_etype1504, _size1501); - (*(this->success)).resize(_size1501); - uint32_t _i1505; - for (_i1505 = 0; _i1505 < _size1501; ++_i1505) + uint32_t _size1511; + ::apache::thrift::protocol::TType _etype1514; + xfer += iprot->readListBegin(_etype1514, _size1511); + (*(this->success)).resize(_size1511); + uint32_t _i1515; + for (_i1515 = 0; _i1515 < _size1511; ++_i1515) { - xfer += (*(this->success))[_i1505].read(iprot); + xfer += (*(this->success))[_i1515].read(iprot); } xfer += iprot->readListEnd(); } @@ -18417,14 +18417,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 _size1506; - ::apache::thrift::protocol::TType _etype1509; - xfer += iprot->readListBegin(_etype1509, _size1506); - this->part_vals.resize(_size1506); - uint32_t _i1510; - for (_i1510 = 0; _i1510 < _size1506; ++_i1510) + uint32_t _size1516; + ::apache::thrift::protocol::TType _etype1519; + xfer += iprot->readListBegin(_etype1519, _size1516); + this->part_vals.resize(_size1516); + uint32_t _i1520; + for (_i1520 = 0; _i1520 < _size1516; ++_i1520) { - xfer += iprot->readString(this->part_vals[_i1510]); + xfer += iprot->readString(this->part_vals[_i1520]); } xfer += iprot->readListEnd(); } @@ -18469,10 +18469,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 _iter1511; - for (_iter1511 = this->part_vals.begin(); _iter1511 != this->part_vals.end(); ++_iter1511) + std::vector ::const_iterator _iter1521; + for (_iter1521 = this->part_vals.begin(); _iter1521 != this->part_vals.end(); ++_iter1521) { - xfer += oprot->writeString((*_iter1511)); + xfer += oprot->writeString((*_iter1521)); } xfer += oprot->writeListEnd(); } @@ -18508,10 +18508,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 _iter1512; - for (_iter1512 = (*(this->part_vals)).begin(); _iter1512 != (*(this->part_vals)).end(); ++_iter1512) + std::vector ::const_iterator _iter1522; + for (_iter1522 = (*(this->part_vals)).begin(); _iter1522 != (*(this->part_vals)).end(); ++_iter1522) { - xfer += oprot->writeString((*_iter1512)); + xfer += oprot->writeString((*_iter1522)); } xfer += oprot->writeListEnd(); } @@ -18556,14 +18556,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1513; - ::apache::thrift::protocol::TType _etype1516; - xfer += iprot->readListBegin(_etype1516, _size1513); - this->success.resize(_size1513); - uint32_t _i1517; - for (_i1517 = 0; _i1517 < _size1513; ++_i1517) + uint32_t _size1523; + ::apache::thrift::protocol::TType _etype1526; + xfer += iprot->readListBegin(_etype1526, _size1523); + this->success.resize(_size1523); + uint32_t _i1527; + for (_i1527 = 0; _i1527 < _size1523; ++_i1527) { - xfer += iprot->readString(this->success[_i1517]); + xfer += iprot->readString(this->success[_i1527]); } xfer += iprot->readListEnd(); } @@ -18610,10 +18610,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 _iter1518; - for (_iter1518 = this->success.begin(); _iter1518 != this->success.end(); ++_iter1518) + std::vector ::const_iterator _iter1528; + for (_iter1528 = this->success.begin(); _iter1528 != this->success.end(); ++_iter1528) { - xfer += oprot->writeString((*_iter1518)); + xfer += oprot->writeString((*_iter1528)); } xfer += oprot->writeListEnd(); } @@ -18662,14 +18662,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1519; - ::apache::thrift::protocol::TType _etype1522; - xfer += iprot->readListBegin(_etype1522, _size1519); - (*(this->success)).resize(_size1519); - uint32_t _i1523; - for (_i1523 = 0; _i1523 < _size1519; ++_i1523) + uint32_t _size1529; + ::apache::thrift::protocol::TType _etype1532; + xfer += iprot->readListBegin(_etype1532, _size1529); + (*(this->success)).resize(_size1529); + uint32_t _i1533; + for (_i1533 = 0; _i1533 < _size1529; ++_i1533) { - xfer += iprot->readString((*(this->success))[_i1523]); + xfer += iprot->readString((*(this->success))[_i1533]); } xfer += iprot->readListEnd(); } @@ -18863,14 +18863,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1524; - ::apache::thrift::protocol::TType _etype1527; - xfer += iprot->readListBegin(_etype1527, _size1524); - this->success.resize(_size1524); - uint32_t _i1528; - for (_i1528 = 0; _i1528 < _size1524; ++_i1528) + uint32_t _size1534; + ::apache::thrift::protocol::TType _etype1537; + xfer += iprot->readListBegin(_etype1537, _size1534); + this->success.resize(_size1534); + uint32_t _i1538; + for (_i1538 = 0; _i1538 < _size1534; ++_i1538) { - xfer += this->success[_i1528].read(iprot); + xfer += this->success[_i1538].read(iprot); } xfer += iprot->readListEnd(); } @@ -18917,10 +18917,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 _iter1529; - for (_iter1529 = this->success.begin(); _iter1529 != this->success.end(); ++_iter1529) + std::vector ::const_iterator _iter1539; + for (_iter1539 = this->success.begin(); _iter1539 != this->success.end(); ++_iter1539) { - xfer += (*_iter1529).write(oprot); + xfer += (*_iter1539).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18969,14 +18969,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1530; - ::apache::thrift::protocol::TType _etype1533; - xfer += iprot->readListBegin(_etype1533, _size1530); - (*(this->success)).resize(_size1530); - uint32_t _i1534; - for (_i1534 = 0; _i1534 < _size1530; ++_i1534) + uint32_t _size1540; + ::apache::thrift::protocol::TType _etype1543; + xfer += iprot->readListBegin(_etype1543, _size1540); + (*(this->success)).resize(_size1540); + uint32_t _i1544; + for (_i1544 = 0; _i1544 < _size1540; ++_i1544) { - xfer += (*(this->success))[_i1534].read(iprot); + xfer += (*(this->success))[_i1544].read(iprot); } xfer += iprot->readListEnd(); } @@ -19170,14 +19170,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 _size1535; - ::apache::thrift::protocol::TType _etype1538; - xfer += iprot->readListBegin(_etype1538, _size1535); - this->success.resize(_size1535); - uint32_t _i1539; - for (_i1539 = 0; _i1539 < _size1535; ++_i1539) + uint32_t _size1545; + ::apache::thrift::protocol::TType _etype1548; + xfer += iprot->readListBegin(_etype1548, _size1545); + this->success.resize(_size1545); + uint32_t _i1549; + for (_i1549 = 0; _i1549 < _size1545; ++_i1549) { - xfer += this->success[_i1539].read(iprot); + xfer += this->success[_i1549].read(iprot); } xfer += iprot->readListEnd(); } @@ -19224,10 +19224,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 _iter1540; - for (_iter1540 = this->success.begin(); _iter1540 != this->success.end(); ++_iter1540) + std::vector ::const_iterator _iter1550; + for (_iter1550 = this->success.begin(); _iter1550 != this->success.end(); ++_iter1550) { - xfer += (*_iter1540).write(oprot); + xfer += (*_iter1550).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19276,14 +19276,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 _size1541; - ::apache::thrift::protocol::TType _etype1544; - xfer += iprot->readListBegin(_etype1544, _size1541); - (*(this->success)).resize(_size1541); - uint32_t _i1545; - for (_i1545 = 0; _i1545 < _size1541; ++_i1545) + uint32_t _size1551; + ::apache::thrift::protocol::TType _etype1554; + xfer += iprot->readListBegin(_etype1554, _size1551); + (*(this->success)).resize(_size1551); + uint32_t _i1555; + for (_i1555 = 0; _i1555 < _size1551; ++_i1555) { - xfer += (*(this->success))[_i1545].read(iprot); + xfer += (*(this->success))[_i1555].read(iprot); } xfer += iprot->readListEnd(); } @@ -19852,14 +19852,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1546; - ::apache::thrift::protocol::TType _etype1549; - xfer += iprot->readListBegin(_etype1549, _size1546); - this->names.resize(_size1546); - uint32_t _i1550; - for (_i1550 = 0; _i1550 < _size1546; ++_i1550) + uint32_t _size1556; + ::apache::thrift::protocol::TType _etype1559; + xfer += iprot->readListBegin(_etype1559, _size1556); + this->names.resize(_size1556); + uint32_t _i1560; + for (_i1560 = 0; _i1560 < _size1556; ++_i1560) { - xfer += iprot->readString(this->names[_i1550]); + xfer += iprot->readString(this->names[_i1560]); } xfer += iprot->readListEnd(); } @@ -19896,10 +19896,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 _iter1551; - for (_iter1551 = this->names.begin(); _iter1551 != this->names.end(); ++_iter1551) + std::vector ::const_iterator _iter1561; + for (_iter1561 = this->names.begin(); _iter1561 != this->names.end(); ++_iter1561) { - xfer += oprot->writeString((*_iter1551)); + xfer += oprot->writeString((*_iter1561)); } xfer += oprot->writeListEnd(); } @@ -19931,10 +19931,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 _iter1552; - for (_iter1552 = (*(this->names)).begin(); _iter1552 != (*(this->names)).end(); ++_iter1552) + std::vector ::const_iterator _iter1562; + for (_iter1562 = (*(this->names)).begin(); _iter1562 != (*(this->names)).end(); ++_iter1562) { - xfer += oprot->writeString((*_iter1552)); + xfer += oprot->writeString((*_iter1562)); } xfer += oprot->writeListEnd(); } @@ -19975,14 +19975,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1553; - ::apache::thrift::protocol::TType _etype1556; - xfer += iprot->readListBegin(_etype1556, _size1553); - this->success.resize(_size1553); - uint32_t _i1557; - for (_i1557 = 0; _i1557 < _size1553; ++_i1557) + uint32_t _size1563; + ::apache::thrift::protocol::TType _etype1566; + xfer += iprot->readListBegin(_etype1566, _size1563); + this->success.resize(_size1563); + uint32_t _i1567; + for (_i1567 = 0; _i1567 < _size1563; ++_i1567) { - xfer += this->success[_i1557].read(iprot); + xfer += this->success[_i1567].read(iprot); } xfer += iprot->readListEnd(); } @@ -20029,10 +20029,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 _iter1558; - for (_iter1558 = this->success.begin(); _iter1558 != this->success.end(); ++_iter1558) + std::vector ::const_iterator _iter1568; + for (_iter1568 = this->success.begin(); _iter1568 != this->success.end(); ++_iter1568) { - xfer += (*_iter1558).write(oprot); + xfer += (*_iter1568).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20081,14 +20081,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1559; - ::apache::thrift::protocol::TType _etype1562; - xfer += iprot->readListBegin(_etype1562, _size1559); - (*(this->success)).resize(_size1559); - uint32_t _i1563; - for (_i1563 = 0; _i1563 < _size1559; ++_i1563) + uint32_t _size1569; + ::apache::thrift::protocol::TType _etype1572; + xfer += iprot->readListBegin(_etype1572, _size1569); + (*(this->success)).resize(_size1569); + uint32_t _i1573; + for (_i1573 = 0; _i1573 < _size1569; ++_i1573) { - xfer += (*(this->success))[_i1563].read(iprot); + xfer += (*(this->success))[_i1573].read(iprot); } xfer += iprot->readListEnd(); } @@ -20410,14 +20410,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1564; - ::apache::thrift::protocol::TType _etype1567; - xfer += iprot->readListBegin(_etype1567, _size1564); - this->new_parts.resize(_size1564); - uint32_t _i1568; - for (_i1568 = 0; _i1568 < _size1564; ++_i1568) + uint32_t _size1574; + ::apache::thrift::protocol::TType _etype1577; + xfer += iprot->readListBegin(_etype1577, _size1574); + this->new_parts.resize(_size1574); + uint32_t _i1578; + for (_i1578 = 0; _i1578 < _size1574; ++_i1578) { - xfer += this->new_parts[_i1568].read(iprot); + xfer += this->new_parts[_i1578].read(iprot); } xfer += iprot->readListEnd(); } @@ -20454,10 +20454,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 _iter1569; - for (_iter1569 = this->new_parts.begin(); _iter1569 != this->new_parts.end(); ++_iter1569) + std::vector ::const_iterator _iter1579; + for (_iter1579 = this->new_parts.begin(); _iter1579 != this->new_parts.end(); ++_iter1579) { - xfer += (*_iter1569).write(oprot); + xfer += (*_iter1579).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20489,10 +20489,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 _iter1570; - for (_iter1570 = (*(this->new_parts)).begin(); _iter1570 != (*(this->new_parts)).end(); ++_iter1570) + std::vector ::const_iterator _iter1580; + for (_iter1580 = (*(this->new_parts)).begin(); _iter1580 != (*(this->new_parts)).end(); ++_iter1580) { - xfer += (*_iter1570).write(oprot); + xfer += (*_iter1580).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20677,14 +20677,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1571; - ::apache::thrift::protocol::TType _etype1574; - xfer += iprot->readListBegin(_etype1574, _size1571); - this->new_parts.resize(_size1571); - uint32_t _i1575; - for (_i1575 = 0; _i1575 < _size1571; ++_i1575) + uint32_t _size1581; + ::apache::thrift::protocol::TType _etype1584; + xfer += iprot->readListBegin(_etype1584, _size1581); + this->new_parts.resize(_size1581); + uint32_t _i1585; + for (_i1585 = 0; _i1585 < _size1581; ++_i1585) { - xfer += this->new_parts[_i1575].read(iprot); + xfer += this->new_parts[_i1585].read(iprot); } xfer += iprot->readListEnd(); } @@ -20729,10 +20729,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 _iter1576; - for (_iter1576 = this->new_parts.begin(); _iter1576 != this->new_parts.end(); ++_iter1576) + std::vector ::const_iterator _iter1586; + for (_iter1586 = this->new_parts.begin(); _iter1586 != this->new_parts.end(); ++_iter1586) { - xfer += (*_iter1576).write(oprot); + xfer += (*_iter1586).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20768,10 +20768,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 _iter1577; - for (_iter1577 = (*(this->new_parts)).begin(); _iter1577 != (*(this->new_parts)).end(); ++_iter1577) + std::vector ::const_iterator _iter1587; + for (_iter1587 = (*(this->new_parts)).begin(); _iter1587 != (*(this->new_parts)).end(); ++_iter1587) { - xfer += (*_iter1577).write(oprot); + xfer += (*_iter1587).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21215,14 +21215,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1578; - ::apache::thrift::protocol::TType _etype1581; - xfer += iprot->readListBegin(_etype1581, _size1578); - this->part_vals.resize(_size1578); - uint32_t _i1582; - for (_i1582 = 0; _i1582 < _size1578; ++_i1582) + uint32_t _size1588; + ::apache::thrift::protocol::TType _etype1591; + xfer += iprot->readListBegin(_etype1591, _size1588); + this->part_vals.resize(_size1588); + uint32_t _i1592; + for (_i1592 = 0; _i1592 < _size1588; ++_i1592) { - xfer += iprot->readString(this->part_vals[_i1582]); + xfer += iprot->readString(this->part_vals[_i1592]); } xfer += iprot->readListEnd(); } @@ -21267,10 +21267,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 _iter1583; - for (_iter1583 = this->part_vals.begin(); _iter1583 != this->part_vals.end(); ++_iter1583) + std::vector ::const_iterator _iter1593; + for (_iter1593 = this->part_vals.begin(); _iter1593 != this->part_vals.end(); ++_iter1593) { - xfer += oprot->writeString((*_iter1583)); + xfer += oprot->writeString((*_iter1593)); } xfer += oprot->writeListEnd(); } @@ -21306,10 +21306,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 _iter1584; - for (_iter1584 = (*(this->part_vals)).begin(); _iter1584 != (*(this->part_vals)).end(); ++_iter1584) + std::vector ::const_iterator _iter1594; + for (_iter1594 = (*(this->part_vals)).begin(); _iter1594 != (*(this->part_vals)).end(); ++_iter1594) { - xfer += oprot->writeString((*_iter1584)); + xfer += oprot->writeString((*_iter1594)); } xfer += oprot->writeListEnd(); } @@ -21482,14 +21482,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 _size1585; - ::apache::thrift::protocol::TType _etype1588; - xfer += iprot->readListBegin(_etype1588, _size1585); - this->part_vals.resize(_size1585); - uint32_t _i1589; - for (_i1589 = 0; _i1589 < _size1585; ++_i1589) + uint32_t _size1595; + ::apache::thrift::protocol::TType _etype1598; + xfer += iprot->readListBegin(_etype1598, _size1595); + this->part_vals.resize(_size1595); + uint32_t _i1599; + for (_i1599 = 0; _i1599 < _size1595; ++_i1599) { - xfer += iprot->readString(this->part_vals[_i1589]); + xfer += iprot->readString(this->part_vals[_i1599]); } xfer += iprot->readListEnd(); } @@ -21526,10 +21526,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 _iter1590; - for (_iter1590 = this->part_vals.begin(); _iter1590 != this->part_vals.end(); ++_iter1590) + std::vector ::const_iterator _iter1600; + for (_iter1600 = this->part_vals.begin(); _iter1600 != this->part_vals.end(); ++_iter1600) { - xfer += oprot->writeString((*_iter1590)); + xfer += oprot->writeString((*_iter1600)); } xfer += oprot->writeListEnd(); } @@ -21557,10 +21557,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 _iter1591; - for (_iter1591 = (*(this->part_vals)).begin(); _iter1591 != (*(this->part_vals)).end(); ++_iter1591) + std::vector ::const_iterator _iter1601; + for (_iter1601 = (*(this->part_vals)).begin(); _iter1601 != (*(this->part_vals)).end(); ++_iter1601) { - xfer += oprot->writeString((*_iter1591)); + xfer += oprot->writeString((*_iter1601)); } xfer += oprot->writeListEnd(); } @@ -22035,14 +22035,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1592; - ::apache::thrift::protocol::TType _etype1595; - xfer += iprot->readListBegin(_etype1595, _size1592); - this->success.resize(_size1592); - uint32_t _i1596; - for (_i1596 = 0; _i1596 < _size1592; ++_i1596) + uint32_t _size1602; + ::apache::thrift::protocol::TType _etype1605; + xfer += iprot->readListBegin(_etype1605, _size1602); + this->success.resize(_size1602); + uint32_t _i1606; + for (_i1606 = 0; _i1606 < _size1602; ++_i1606) { - xfer += iprot->readString(this->success[_i1596]); + xfer += iprot->readString(this->success[_i1606]); } xfer += iprot->readListEnd(); } @@ -22081,10 +22081,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 _iter1597; - for (_iter1597 = this->success.begin(); _iter1597 != this->success.end(); ++_iter1597) + std::vector ::const_iterator _iter1607; + for (_iter1607 = this->success.begin(); _iter1607 != this->success.end(); ++_iter1607) { - xfer += oprot->writeString((*_iter1597)); + xfer += oprot->writeString((*_iter1607)); } xfer += oprot->writeListEnd(); } @@ -22129,14 +22129,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1598; - ::apache::thrift::protocol::TType _etype1601; - xfer += iprot->readListBegin(_etype1601, _size1598); - (*(this->success)).resize(_size1598); - uint32_t _i1602; - for (_i1602 = 0; _i1602 < _size1598; ++_i1602) + uint32_t _size1608; + ::apache::thrift::protocol::TType _etype1611; + xfer += iprot->readListBegin(_etype1611, _size1608); + (*(this->success)).resize(_size1608); + uint32_t _i1612; + for (_i1612 = 0; _i1612 < _size1608; ++_i1612) { - xfer += iprot->readString((*(this->success))[_i1602]); + xfer += iprot->readString((*(this->success))[_i1612]); } xfer += iprot->readListEnd(); } @@ -22274,17 +22274,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1603; - ::apache::thrift::protocol::TType _ktype1604; - ::apache::thrift::protocol::TType _vtype1605; - xfer += iprot->readMapBegin(_ktype1604, _vtype1605, _size1603); - uint32_t _i1607; - for (_i1607 = 0; _i1607 < _size1603; ++_i1607) + uint32_t _size1613; + ::apache::thrift::protocol::TType _ktype1614; + ::apache::thrift::protocol::TType _vtype1615; + xfer += iprot->readMapBegin(_ktype1614, _vtype1615, _size1613); + uint32_t _i1617; + for (_i1617 = 0; _i1617 < _size1613; ++_i1617) { - std::string _key1608; - xfer += iprot->readString(_key1608); - std::string& _val1609 = this->success[_key1608]; - xfer += iprot->readString(_val1609); + std::string _key1618; + xfer += iprot->readString(_key1618); + std::string& _val1619 = this->success[_key1618]; + xfer += iprot->readString(_val1619); } xfer += iprot->readMapEnd(); } @@ -22323,11 +22323,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 _iter1610; - for (_iter1610 = this->success.begin(); _iter1610 != this->success.end(); ++_iter1610) + std::map ::const_iterator _iter1620; + for (_iter1620 = this->success.begin(); _iter1620 != this->success.end(); ++_iter1620) { - xfer += oprot->writeString(_iter1610->first); - xfer += oprot->writeString(_iter1610->second); + xfer += oprot->writeString(_iter1620->first); + xfer += oprot->writeString(_iter1620->second); } xfer += oprot->writeMapEnd(); } @@ -22372,17 +22372,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1611; - ::apache::thrift::protocol::TType _ktype1612; - ::apache::thrift::protocol::TType _vtype1613; - xfer += iprot->readMapBegin(_ktype1612, _vtype1613, _size1611); - uint32_t _i1615; - for (_i1615 = 0; _i1615 < _size1611; ++_i1615) + uint32_t _size1621; + ::apache::thrift::protocol::TType _ktype1622; + ::apache::thrift::protocol::TType _vtype1623; + xfer += iprot->readMapBegin(_ktype1622, _vtype1623, _size1621); + uint32_t _i1625; + for (_i1625 = 0; _i1625 < _size1621; ++_i1625) { - std::string _key1616; - xfer += iprot->readString(_key1616); - std::string& _val1617 = (*(this->success))[_key1616]; - xfer += iprot->readString(_val1617); + std::string _key1626; + xfer += iprot->readString(_key1626); + std::string& _val1627 = (*(this->success))[_key1626]; + xfer += iprot->readString(_val1627); } xfer += iprot->readMapEnd(); } @@ -22457,17 +22457,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1618; - ::apache::thrift::protocol::TType _ktype1619; - ::apache::thrift::protocol::TType _vtype1620; - xfer += iprot->readMapBegin(_ktype1619, _vtype1620, _size1618); - uint32_t _i1622; - for (_i1622 = 0; _i1622 < _size1618; ++_i1622) + uint32_t _size1628; + ::apache::thrift::protocol::TType _ktype1629; + ::apache::thrift::protocol::TType _vtype1630; + xfer += iprot->readMapBegin(_ktype1629, _vtype1630, _size1628); + uint32_t _i1632; + for (_i1632 = 0; _i1632 < _size1628; ++_i1632) { - std::string _key1623; - xfer += iprot->readString(_key1623); - std::string& _val1624 = this->part_vals[_key1623]; - xfer += iprot->readString(_val1624); + std::string _key1633; + xfer += iprot->readString(_key1633); + std::string& _val1634 = this->part_vals[_key1633]; + xfer += iprot->readString(_val1634); } xfer += iprot->readMapEnd(); } @@ -22478,9 +22478,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1625; - xfer += iprot->readI32(ecast1625); - this->eventType = (PartitionEventType::type)ecast1625; + int32_t ecast1635; + xfer += iprot->readI32(ecast1635); + this->eventType = (PartitionEventType::type)ecast1635; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -22514,11 +22514,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 _iter1626; - for (_iter1626 = this->part_vals.begin(); _iter1626 != this->part_vals.end(); ++_iter1626) + std::map ::const_iterator _iter1636; + for (_iter1636 = this->part_vals.begin(); _iter1636 != this->part_vals.end(); ++_iter1636) { - xfer += oprot->writeString(_iter1626->first); - xfer += oprot->writeString(_iter1626->second); + xfer += oprot->writeString(_iter1636->first); + xfer += oprot->writeString(_iter1636->second); } xfer += oprot->writeMapEnd(); } @@ -22554,11 +22554,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 _iter1627; - for (_iter1627 = (*(this->part_vals)).begin(); _iter1627 != (*(this->part_vals)).end(); ++_iter1627) + std::map ::const_iterator _iter1637; + for (_iter1637 = (*(this->part_vals)).begin(); _iter1637 != (*(this->part_vals)).end(); ++_iter1637) { - xfer += oprot->writeString(_iter1627->first); - xfer += oprot->writeString(_iter1627->second); + xfer += oprot->writeString(_iter1637->first); + xfer += oprot->writeString(_iter1637->second); } xfer += oprot->writeMapEnd(); } @@ -22827,17 +22827,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1628; - ::apache::thrift::protocol::TType _ktype1629; - ::apache::thrift::protocol::TType _vtype1630; - xfer += iprot->readMapBegin(_ktype1629, _vtype1630, _size1628); - uint32_t _i1632; - for (_i1632 = 0; _i1632 < _size1628; ++_i1632) + uint32_t _size1638; + ::apache::thrift::protocol::TType _ktype1639; + ::apache::thrift::protocol::TType _vtype1640; + xfer += iprot->readMapBegin(_ktype1639, _vtype1640, _size1638); + uint32_t _i1642; + for (_i1642 = 0; _i1642 < _size1638; ++_i1642) { - std::string _key1633; - xfer += iprot->readString(_key1633); - std::string& _val1634 = this->part_vals[_key1633]; - xfer += iprot->readString(_val1634); + std::string _key1643; + xfer += iprot->readString(_key1643); + std::string& _val1644 = this->part_vals[_key1643]; + xfer += iprot->readString(_val1644); } xfer += iprot->readMapEnd(); } @@ -22848,9 +22848,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1635; - xfer += iprot->readI32(ecast1635); - this->eventType = (PartitionEventType::type)ecast1635; + int32_t ecast1645; + xfer += iprot->readI32(ecast1645); + this->eventType = (PartitionEventType::type)ecast1645; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -22884,11 +22884,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 _iter1636; - for (_iter1636 = this->part_vals.begin(); _iter1636 != this->part_vals.end(); ++_iter1636) + std::map ::const_iterator _iter1646; + for (_iter1646 = this->part_vals.begin(); _iter1646 != this->part_vals.end(); ++_iter1646) { - xfer += oprot->writeString(_iter1636->first); - xfer += oprot->writeString(_iter1636->second); + xfer += oprot->writeString(_iter1646->first); + xfer += oprot->writeString(_iter1646->second); } xfer += oprot->writeMapEnd(); } @@ -22924,11 +22924,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 _iter1637; - for (_iter1637 = (*(this->part_vals)).begin(); _iter1637 != (*(this->part_vals)).end(); ++_iter1637) + std::map ::const_iterator _iter1647; + for (_iter1647 = (*(this->part_vals)).begin(); _iter1647 != (*(this->part_vals)).end(); ++_iter1647) { - xfer += oprot->writeString(_iter1637->first); - xfer += oprot->writeString(_iter1637->second); + xfer += oprot->writeString(_iter1647->first); + xfer += oprot->writeString(_iter1647->second); } xfer += oprot->writeMapEnd(); } @@ -24364,14 +24364,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1638; - ::apache::thrift::protocol::TType _etype1641; - xfer += iprot->readListBegin(_etype1641, _size1638); - this->success.resize(_size1638); - uint32_t _i1642; - for (_i1642 = 0; _i1642 < _size1638; ++_i1642) + uint32_t _size1648; + ::apache::thrift::protocol::TType _etype1651; + xfer += iprot->readListBegin(_etype1651, _size1648); + this->success.resize(_size1648); + uint32_t _i1652; + for (_i1652 = 0; _i1652 < _size1648; ++_i1652) { - xfer += this->success[_i1642].read(iprot); + xfer += this->success[_i1652].read(iprot); } xfer += iprot->readListEnd(); } @@ -24418,10 +24418,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 _iter1643; - for (_iter1643 = this->success.begin(); _iter1643 != this->success.end(); ++_iter1643) + std::vector ::const_iterator _iter1653; + for (_iter1653 = this->success.begin(); _iter1653 != this->success.end(); ++_iter1653) { - xfer += (*_iter1643).write(oprot); + xfer += (*_iter1653).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24470,14 +24470,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1644; - ::apache::thrift::protocol::TType _etype1647; - xfer += iprot->readListBegin(_etype1647, _size1644); - (*(this->success)).resize(_size1644); - uint32_t _i1648; - for (_i1648 = 0; _i1648 < _size1644; ++_i1648) + uint32_t _size1654; + ::apache::thrift::protocol::TType _etype1657; + xfer += iprot->readListBegin(_etype1657, _size1654); + (*(this->success)).resize(_size1654); + uint32_t _i1658; + for (_i1658 = 0; _i1658 < _size1654; ++_i1658) { - xfer += (*(this->success))[_i1648].read(iprot); + xfer += (*(this->success))[_i1658].read(iprot); } xfer += iprot->readListEnd(); } @@ -24655,14 +24655,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1649; - ::apache::thrift::protocol::TType _etype1652; - xfer += iprot->readListBegin(_etype1652, _size1649); - this->success.resize(_size1649); - uint32_t _i1653; - for (_i1653 = 0; _i1653 < _size1649; ++_i1653) + uint32_t _size1659; + ::apache::thrift::protocol::TType _etype1662; + xfer += iprot->readListBegin(_etype1662, _size1659); + this->success.resize(_size1659); + uint32_t _i1663; + for (_i1663 = 0; _i1663 < _size1659; ++_i1663) { - xfer += iprot->readString(this->success[_i1653]); + xfer += iprot->readString(this->success[_i1663]); } xfer += iprot->readListEnd(); } @@ -24701,10 +24701,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 _iter1654; - for (_iter1654 = this->success.begin(); _iter1654 != this->success.end(); ++_iter1654) + std::vector ::const_iterator _iter1664; + for (_iter1664 = this->success.begin(); _iter1664 != this->success.end(); ++_iter1664) { - xfer += oprot->writeString((*_iter1654)); + xfer += oprot->writeString((*_iter1664)); } xfer += oprot->writeListEnd(); } @@ -24749,14 +24749,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1655; - ::apache::thrift::protocol::TType _etype1658; - xfer += iprot->readListBegin(_etype1658, _size1655); - (*(this->success)).resize(_size1655); - uint32_t _i1659; - for (_i1659 = 0; _i1659 < _size1655; ++_i1659) + uint32_t _size1665; + ::apache::thrift::protocol::TType _etype1668; + xfer += iprot->readListBegin(_etype1668, _size1665); + (*(this->success)).resize(_size1665); + uint32_t _i1669; + for (_i1669 = 0; _i1669 < _size1665; ++_i1669) { - xfer += iprot->readString((*(this->success))[_i1659]); + xfer += iprot->readString((*(this->success))[_i1669]); } xfer += iprot->readListEnd(); } @@ -29237,14 +29237,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1660; - ::apache::thrift::protocol::TType _etype1663; - xfer += iprot->readListBegin(_etype1663, _size1660); - this->success.resize(_size1660); - uint32_t _i1664; - for (_i1664 = 0; _i1664 < _size1660; ++_i1664) + uint32_t _size1670; + ::apache::thrift::protocol::TType _etype1673; + xfer += iprot->readListBegin(_etype1673, _size1670); + this->success.resize(_size1670); + uint32_t _i1674; + for (_i1674 = 0; _i1674 < _size1670; ++_i1674) { - xfer += iprot->readString(this->success[_i1664]); + xfer += iprot->readString(this->success[_i1674]); } xfer += iprot->readListEnd(); } @@ -29283,10 +29283,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 _iter1665; - for (_iter1665 = this->success.begin(); _iter1665 != this->success.end(); ++_iter1665) + std::vector ::const_iterator _iter1675; + for (_iter1675 = this->success.begin(); _iter1675 != this->success.end(); ++_iter1675) { - xfer += oprot->writeString((*_iter1665)); + xfer += oprot->writeString((*_iter1675)); } xfer += oprot->writeListEnd(); } @@ -29331,14 +29331,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1666; - ::apache::thrift::protocol::TType _etype1669; - xfer += iprot->readListBegin(_etype1669, _size1666); - (*(this->success)).resize(_size1666); - uint32_t _i1670; - for (_i1670 = 0; _i1670 < _size1666; ++_i1670) + uint32_t _size1676; + ::apache::thrift::protocol::TType _etype1679; + xfer += iprot->readListBegin(_etype1679, _size1676); + (*(this->success)).resize(_size1676); + uint32_t _i1680; + for (_i1680 = 0; _i1680 < _size1676; ++_i1680) { - xfer += iprot->readString((*(this->success))[_i1670]); + xfer += iprot->readString((*(this->success))[_i1680]); } xfer += iprot->readListEnd(); } @@ -30298,14 +30298,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1671; - ::apache::thrift::protocol::TType _etype1674; - xfer += iprot->readListBegin(_etype1674, _size1671); - this->success.resize(_size1671); - uint32_t _i1675; - for (_i1675 = 0; _i1675 < _size1671; ++_i1675) + uint32_t _size1681; + ::apache::thrift::protocol::TType _etype1684; + xfer += iprot->readListBegin(_etype1684, _size1681); + this->success.resize(_size1681); + uint32_t _i1685; + for (_i1685 = 0; _i1685 < _size1681; ++_i1685) { - xfer += iprot->readString(this->success[_i1675]); + xfer += iprot->readString(this->success[_i1685]); } xfer += iprot->readListEnd(); } @@ -30344,10 +30344,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 _iter1676; - for (_iter1676 = this->success.begin(); _iter1676 != this->success.end(); ++_iter1676) + std::vector ::const_iterator _iter1686; + for (_iter1686 = this->success.begin(); _iter1686 != this->success.end(); ++_iter1686) { - xfer += oprot->writeString((*_iter1676)); + xfer += oprot->writeString((*_iter1686)); } xfer += oprot->writeListEnd(); } @@ -30392,14 +30392,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1677; - ::apache::thrift::protocol::TType _etype1680; - xfer += iprot->readListBegin(_etype1680, _size1677); - (*(this->success)).resize(_size1677); - uint32_t _i1681; - for (_i1681 = 0; _i1681 < _size1677; ++_i1681) + uint32_t _size1687; + ::apache::thrift::protocol::TType _etype1690; + xfer += iprot->readListBegin(_etype1690, _size1687); + (*(this->success)).resize(_size1687); + uint32_t _i1691; + for (_i1691 = 0; _i1691 < _size1687; ++_i1691) { - xfer += iprot->readString((*(this->success))[_i1681]); + xfer += iprot->readString((*(this->success))[_i1691]); } xfer += iprot->readListEnd(); } @@ -30472,9 +30472,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1682; - xfer += iprot->readI32(ecast1682); - this->principal_type = (PrincipalType::type)ecast1682; + int32_t ecast1692; + xfer += iprot->readI32(ecast1692); + this->principal_type = (PrincipalType::type)ecast1692; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30490,9 +30490,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1683; - xfer += iprot->readI32(ecast1683); - this->grantorType = (PrincipalType::type)ecast1683; + int32_t ecast1693; + xfer += iprot->readI32(ecast1693); + this->grantorType = (PrincipalType::type)ecast1693; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -30763,9 +30763,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1684; - xfer += iprot->readI32(ecast1684); - this->principal_type = (PrincipalType::type)ecast1684; + int32_t ecast1694; + xfer += iprot->readI32(ecast1694); + this->principal_type = (PrincipalType::type)ecast1694; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30996,9 +30996,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1685; - xfer += iprot->readI32(ecast1685); - this->principal_type = (PrincipalType::type)ecast1685; + int32_t ecast1695; + xfer += iprot->readI32(ecast1695); + this->principal_type = (PrincipalType::type)ecast1695; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -31087,14 +31087,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1686; - ::apache::thrift::protocol::TType _etype1689; - xfer += iprot->readListBegin(_etype1689, _size1686); - this->success.resize(_size1686); - uint32_t _i1690; - for (_i1690 = 0; _i1690 < _size1686; ++_i1690) + uint32_t _size1696; + ::apache::thrift::protocol::TType _etype1699; + xfer += iprot->readListBegin(_etype1699, _size1696); + this->success.resize(_size1696); + uint32_t _i1700; + for (_i1700 = 0; _i1700 < _size1696; ++_i1700) { - xfer += this->success[_i1690].read(iprot); + xfer += this->success[_i1700].read(iprot); } xfer += iprot->readListEnd(); } @@ -31133,10 +31133,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 _iter1691; - for (_iter1691 = this->success.begin(); _iter1691 != this->success.end(); ++_iter1691) + std::vector ::const_iterator _iter1701; + for (_iter1701 = this->success.begin(); _iter1701 != this->success.end(); ++_iter1701) { - xfer += (*_iter1691).write(oprot); + xfer += (*_iter1701).write(oprot); } xfer += oprot->writeListEnd(); } @@ -31181,14 +31181,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1692; - ::apache::thrift::protocol::TType _etype1695; - xfer += iprot->readListBegin(_etype1695, _size1692); - (*(this->success)).resize(_size1692); - uint32_t _i1696; - for (_i1696 = 0; _i1696 < _size1692; ++_i1696) + uint32_t _size1702; + ::apache::thrift::protocol::TType _etype1705; + xfer += iprot->readListBegin(_etype1705, _size1702); + (*(this->success)).resize(_size1702); + uint32_t _i1706; + for (_i1706 = 0; _i1706 < _size1702; ++_i1706) { - xfer += (*(this->success))[_i1696].read(iprot); + xfer += (*(this->success))[_i1706].read(iprot); } xfer += iprot->readListEnd(); } @@ -31884,14 +31884,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 _size1697; - ::apache::thrift::protocol::TType _etype1700; - xfer += iprot->readListBegin(_etype1700, _size1697); - this->group_names.resize(_size1697); - uint32_t _i1701; - for (_i1701 = 0; _i1701 < _size1697; ++_i1701) + uint32_t _size1707; + ::apache::thrift::protocol::TType _etype1710; + xfer += iprot->readListBegin(_etype1710, _size1707); + this->group_names.resize(_size1707); + uint32_t _i1711; + for (_i1711 = 0; _i1711 < _size1707; ++_i1711) { - xfer += iprot->readString(this->group_names[_i1701]); + xfer += iprot->readString(this->group_names[_i1711]); } xfer += iprot->readListEnd(); } @@ -31928,10 +31928,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 _iter1702; - for (_iter1702 = this->group_names.begin(); _iter1702 != this->group_names.end(); ++_iter1702) + std::vector ::const_iterator _iter1712; + for (_iter1712 = this->group_names.begin(); _iter1712 != this->group_names.end(); ++_iter1712) { - xfer += oprot->writeString((*_iter1702)); + xfer += oprot->writeString((*_iter1712)); } xfer += oprot->writeListEnd(); } @@ -31963,10 +31963,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 _iter1703; - for (_iter1703 = (*(this->group_names)).begin(); _iter1703 != (*(this->group_names)).end(); ++_iter1703) + std::vector ::const_iterator _iter1713; + for (_iter1713 = (*(this->group_names)).begin(); _iter1713 != (*(this->group_names)).end(); ++_iter1713) { - xfer += oprot->writeString((*_iter1703)); + xfer += oprot->writeString((*_iter1713)); } xfer += oprot->writeListEnd(); } @@ -32141,9 +32141,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1704; - xfer += iprot->readI32(ecast1704); - this->principal_type = (PrincipalType::type)ecast1704; + int32_t ecast1714; + xfer += iprot->readI32(ecast1714); + this->principal_type = (PrincipalType::type)ecast1714; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -32248,14 +32248,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1705; - ::apache::thrift::protocol::TType _etype1708; - xfer += iprot->readListBegin(_etype1708, _size1705); - this->success.resize(_size1705); - uint32_t _i1709; - for (_i1709 = 0; _i1709 < _size1705; ++_i1709) + uint32_t _size1715; + ::apache::thrift::protocol::TType _etype1718; + xfer += iprot->readListBegin(_etype1718, _size1715); + this->success.resize(_size1715); + uint32_t _i1719; + for (_i1719 = 0; _i1719 < _size1715; ++_i1719) { - xfer += this->success[_i1709].read(iprot); + xfer += this->success[_i1719].read(iprot); } xfer += iprot->readListEnd(); } @@ -32294,10 +32294,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 _iter1710; - for (_iter1710 = this->success.begin(); _iter1710 != this->success.end(); ++_iter1710) + std::vector ::const_iterator _iter1720; + for (_iter1720 = this->success.begin(); _iter1720 != this->success.end(); ++_iter1720) { - xfer += (*_iter1710).write(oprot); + xfer += (*_iter1720).write(oprot); } xfer += oprot->writeListEnd(); } @@ -32342,14 +32342,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1711; - ::apache::thrift::protocol::TType _etype1714; - xfer += iprot->readListBegin(_etype1714, _size1711); - (*(this->success)).resize(_size1711); - uint32_t _i1715; - for (_i1715 = 0; _i1715 < _size1711; ++_i1715) + uint32_t _size1721; + ::apache::thrift::protocol::TType _etype1724; + xfer += iprot->readListBegin(_etype1724, _size1721); + (*(this->success)).resize(_size1721); + uint32_t _i1725; + for (_i1725 = 0; _i1725 < _size1721; ++_i1725) { - xfer += (*(this->success))[_i1715].read(iprot); + xfer += (*(this->success))[_i1725].read(iprot); } xfer += iprot->readListEnd(); } @@ -33037,14 +33037,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 _size1716; - ::apache::thrift::protocol::TType _etype1719; - xfer += iprot->readListBegin(_etype1719, _size1716); - this->group_names.resize(_size1716); - uint32_t _i1720; - for (_i1720 = 0; _i1720 < _size1716; ++_i1720) + uint32_t _size1726; + ::apache::thrift::protocol::TType _etype1729; + xfer += iprot->readListBegin(_etype1729, _size1726); + this->group_names.resize(_size1726); + uint32_t _i1730; + for (_i1730 = 0; _i1730 < _size1726; ++_i1730) { - xfer += iprot->readString(this->group_names[_i1720]); + xfer += iprot->readString(this->group_names[_i1730]); } xfer += iprot->readListEnd(); } @@ -33077,10 +33077,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 _iter1721; - for (_iter1721 = this->group_names.begin(); _iter1721 != this->group_names.end(); ++_iter1721) + std::vector ::const_iterator _iter1731; + for (_iter1731 = this->group_names.begin(); _iter1731 != this->group_names.end(); ++_iter1731) { - xfer += oprot->writeString((*_iter1721)); + xfer += oprot->writeString((*_iter1731)); } xfer += oprot->writeListEnd(); } @@ -33108,10 +33108,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 _iter1722; - for (_iter1722 = (*(this->group_names)).begin(); _iter1722 != (*(this->group_names)).end(); ++_iter1722) + std::vector ::const_iterator _iter1732; + for (_iter1732 = (*(this->group_names)).begin(); _iter1732 != (*(this->group_names)).end(); ++_iter1732) { - xfer += oprot->writeString((*_iter1722)); + xfer += oprot->writeString((*_iter1732)); } xfer += oprot->writeListEnd(); } @@ -33152,14 +33152,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1723; - ::apache::thrift::protocol::TType _etype1726; - xfer += iprot->readListBegin(_etype1726, _size1723); - this->success.resize(_size1723); - uint32_t _i1727; - for (_i1727 = 0; _i1727 < _size1723; ++_i1727) + uint32_t _size1733; + ::apache::thrift::protocol::TType _etype1736; + xfer += iprot->readListBegin(_etype1736, _size1733); + this->success.resize(_size1733); + uint32_t _i1737; + for (_i1737 = 0; _i1737 < _size1733; ++_i1737) { - xfer += iprot->readString(this->success[_i1727]); + xfer += iprot->readString(this->success[_i1737]); } xfer += iprot->readListEnd(); } @@ -33198,10 +33198,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 _iter1728; - for (_iter1728 = this->success.begin(); _iter1728 != this->success.end(); ++_iter1728) + std::vector ::const_iterator _iter1738; + for (_iter1738 = this->success.begin(); _iter1738 != this->success.end(); ++_iter1738) { - xfer += oprot->writeString((*_iter1728)); + xfer += oprot->writeString((*_iter1738)); } xfer += oprot->writeListEnd(); } @@ -33246,14 +33246,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1729; - ::apache::thrift::protocol::TType _etype1732; - xfer += iprot->readListBegin(_etype1732, _size1729); - (*(this->success)).resize(_size1729); - uint32_t _i1733; - for (_i1733 = 0; _i1733 < _size1729; ++_i1733) + uint32_t _size1739; + ::apache::thrift::protocol::TType _etype1742; + xfer += iprot->readListBegin(_etype1742, _size1739); + (*(this->success)).resize(_size1739); + uint32_t _i1743; + for (_i1743 = 0; _i1743 < _size1739; ++_i1743) { - xfer += iprot->readString((*(this->success))[_i1733]); + xfer += iprot->readString((*(this->success))[_i1743]); } xfer += iprot->readListEnd(); } @@ -34564,14 +34564,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1734; - ::apache::thrift::protocol::TType _etype1737; - xfer += iprot->readListBegin(_etype1737, _size1734); - this->success.resize(_size1734); - uint32_t _i1738; - for (_i1738 = 0; _i1738 < _size1734; ++_i1738) + uint32_t _size1744; + ::apache::thrift::protocol::TType _etype1747; + xfer += iprot->readListBegin(_etype1747, _size1744); + this->success.resize(_size1744); + uint32_t _i1748; + for (_i1748 = 0; _i1748 < _size1744; ++_i1748) { - xfer += iprot->readString(this->success[_i1738]); + xfer += iprot->readString(this->success[_i1748]); } xfer += iprot->readListEnd(); } @@ -34602,10 +34602,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 _iter1739; - for (_iter1739 = this->success.begin(); _iter1739 != this->success.end(); ++_iter1739) + std::vector ::const_iterator _iter1749; + for (_iter1749 = this->success.begin(); _iter1749 != this->success.end(); ++_iter1749) { - xfer += oprot->writeString((*_iter1739)); + xfer += oprot->writeString((*_iter1749)); } xfer += oprot->writeListEnd(); } @@ -34646,14 +34646,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1740; - ::apache::thrift::protocol::TType _etype1743; - xfer += iprot->readListBegin(_etype1743, _size1740); - (*(this->success)).resize(_size1740); - uint32_t _i1744; - for (_i1744 = 0; _i1744 < _size1740; ++_i1744) + uint32_t _size1750; + ::apache::thrift::protocol::TType _etype1753; + xfer += iprot->readListBegin(_etype1753, _size1750); + (*(this->success)).resize(_size1750); + uint32_t _i1754; + for (_i1754 = 0; _i1754 < _size1750; ++_i1754) { - xfer += iprot->readString((*(this->success))[_i1744]); + xfer += iprot->readString((*(this->success))[_i1754]); } xfer += iprot->readListEnd(); } @@ -35379,14 +35379,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1745; - ::apache::thrift::protocol::TType _etype1748; - xfer += iprot->readListBegin(_etype1748, _size1745); - this->success.resize(_size1745); - uint32_t _i1749; - for (_i1749 = 0; _i1749 < _size1745; ++_i1749) + uint32_t _size1755; + ::apache::thrift::protocol::TType _etype1758; + xfer += iprot->readListBegin(_etype1758, _size1755); + this->success.resize(_size1755); + uint32_t _i1759; + for (_i1759 = 0; _i1759 < _size1755; ++_i1759) { - xfer += iprot->readString(this->success[_i1749]); + xfer += iprot->readString(this->success[_i1759]); } xfer += iprot->readListEnd(); } @@ -35417,10 +35417,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 _iter1750; - for (_iter1750 = this->success.begin(); _iter1750 != this->success.end(); ++_iter1750) + std::vector ::const_iterator _iter1760; + for (_iter1760 = this->success.begin(); _iter1760 != this->success.end(); ++_iter1760) { - xfer += oprot->writeString((*_iter1750)); + xfer += oprot->writeString((*_iter1760)); } xfer += oprot->writeListEnd(); } @@ -35461,14 +35461,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1751; - ::apache::thrift::protocol::TType _etype1754; - xfer += iprot->readListBegin(_etype1754, _size1751); - (*(this->success)).resize(_size1751); - uint32_t _i1755; - for (_i1755 = 0; _i1755 < _size1751; ++_i1755) + uint32_t _size1761; + ::apache::thrift::protocol::TType _etype1764; + xfer += iprot->readListBegin(_etype1764, _size1761); + (*(this->success)).resize(_size1761); + uint32_t _i1765; + for (_i1765 = 0; _i1765 < _size1761; ++_i1765) { - xfer += iprot->readString((*(this->success))[_i1755]); + xfer += iprot->readString((*(this->success))[_i1765]); } xfer += iprot->readListEnd(); } diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index ef138e00bd..72a516eae5 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -13788,6 +13788,16 @@ void OpenTxnRequest::__set_agentInfo(const std::string& val) { __isset.agentInfo = true; } +void OpenTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void OpenTxnRequest::__set_replSrcTxnId(const std::vector & val) { + this->replSrcTxnId = val; +__isset.replSrcTxnId = true; +} + uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -13844,6 +13854,34 @@ uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->replSrcTxnId.clear(); + uint32_t _size595; + ::apache::thrift::protocol::TType _etype598; + xfer += iprot->readListBegin(_etype598, _size595); + this->replSrcTxnId.resize(_size595); + uint32_t _i599; + for (_i599 = 0; _i599 < _size595; ++_i599) + { + xfer += iprot->readI64(this->replSrcTxnId[_i599]); + } + xfer += iprot->readListEnd(); + } + this->__isset.replSrcTxnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -13884,6 +13922,24 @@ uint32_t OpenTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) con xfer += oprot->writeString(this->agentInfo); xfer += oprot->writeFieldEnd(); } + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replSrcTxnId) { + xfer += oprot->writeFieldBegin("replSrcTxnId", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->replSrcTxnId.size())); + std::vector ::const_iterator _iter600; + for (_iter600 = this->replSrcTxnId.begin(); _iter600 != this->replSrcTxnId.end(); ++_iter600) + { + xfer += oprot->writeI64((*_iter600)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -13895,22 +13951,28 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.user, b.user); swap(a.hostname, b.hostname); swap(a.agentInfo, b.agentInfo); + swap(a.replPolicy, b.replPolicy); + swap(a.replSrcTxnId, b.replSrcTxnId); swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other595) { - num_txns = other595.num_txns; - user = other595.user; - hostname = other595.hostname; - agentInfo = other595.agentInfo; - __isset = other595.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other596) { - num_txns = other596.num_txns; - user = other596.user; - hostname = other596.hostname; - agentInfo = other596.agentInfo; - __isset = other596.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other601) { + num_txns = other601.num_txns; + user = other601.user; + hostname = other601.hostname; + agentInfo = other601.agentInfo; + replPolicy = other601.replPolicy; + replSrcTxnId = other601.replSrcTxnId; + __isset = other601.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other602) { + num_txns = other602.num_txns; + user = other602.user; + hostname = other602.hostname; + agentInfo = other602.agentInfo; + replPolicy = other602.replPolicy; + replSrcTxnId = other602.replSrcTxnId; + __isset = other602.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -13920,6 +13982,8 @@ void OpenTxnRequest::printTo(std::ostream& out) const { out << ", " << "user=" << to_string(user); out << ", " << "hostname=" << to_string(hostname); out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "")); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ", " << "replSrcTxnId="; (__isset.replSrcTxnId ? (out << to_string(replSrcTxnId)) : (out << "")); out << ")"; } @@ -13958,14 +14022,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size597; - ::apache::thrift::protocol::TType _etype600; - xfer += iprot->readListBegin(_etype600, _size597); - this->txn_ids.resize(_size597); - uint32_t _i601; - for (_i601 = 0; _i601 < _size597; ++_i601) + uint32_t _size603; + ::apache::thrift::protocol::TType _etype606; + xfer += iprot->readListBegin(_etype606, _size603); + this->txn_ids.resize(_size603); + uint32_t _i607; + for (_i607 = 0; _i607 < _size603; ++_i607) { - xfer += iprot->readI64(this->txn_ids[_i601]); + xfer += iprot->readI64(this->txn_ids[_i607]); } xfer += iprot->readListEnd(); } @@ -13996,10 +14060,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 _iter602; - for (_iter602 = this->txn_ids.begin(); _iter602 != this->txn_ids.end(); ++_iter602) + std::vector ::const_iterator _iter608; + for (_iter608 = this->txn_ids.begin(); _iter608 != this->txn_ids.end(); ++_iter608) { - xfer += oprot->writeI64((*_iter602)); + xfer += oprot->writeI64((*_iter608)); } xfer += oprot->writeListEnd(); } @@ -14015,11 +14079,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other603) { - txn_ids = other603.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other609) { + txn_ids = other609.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other604) { - txn_ids = other604.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other610) { + txn_ids = other610.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -14038,6 +14102,11 @@ void AbortTxnRequest::__set_txnid(const int64_t val) { this->txnid = val; } +void AbortTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -14068,6 +14137,14 @@ uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -14091,6 +14168,11 @@ uint32_t AbortTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeI64(this->txnid); xfer += oprot->writeFieldEnd(); + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -14099,19 +14181,26 @@ uint32_t AbortTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) co void swap(AbortTxnRequest &a, AbortTxnRequest &b) { using ::std::swap; swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.__isset, b.__isset); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other605) { - txnid = other605.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other611) { + txnid = other611.txnid; + replPolicy = other611.replPolicy; + __isset = other611.__isset; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other606) { - txnid = other606.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other612) { + txnid = other612.txnid; + replPolicy = other612.replPolicy; + __isset = other612.__isset; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "AbortTxnRequest("; out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); out << ")"; } @@ -14150,14 +14239,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size607; - ::apache::thrift::protocol::TType _etype610; - xfer += iprot->readListBegin(_etype610, _size607); - this->txn_ids.resize(_size607); - uint32_t _i611; - for (_i611 = 0; _i611 < _size607; ++_i611) + uint32_t _size613; + ::apache::thrift::protocol::TType _etype616; + xfer += iprot->readListBegin(_etype616, _size613); + this->txn_ids.resize(_size613); + uint32_t _i617; + for (_i617 = 0; _i617 < _size613; ++_i617) { - xfer += iprot->readI64(this->txn_ids[_i611]); + xfer += iprot->readI64(this->txn_ids[_i617]); } xfer += iprot->readListEnd(); } @@ -14188,10 +14277,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 _iter612; - for (_iter612 = this->txn_ids.begin(); _iter612 != this->txn_ids.end(); ++_iter612) + std::vector ::const_iterator _iter618; + for (_iter618 = this->txn_ids.begin(); _iter618 != this->txn_ids.end(); ++_iter618) { - xfer += oprot->writeI64((*_iter612)); + xfer += oprot->writeI64((*_iter618)); } xfer += oprot->writeListEnd(); } @@ -14207,11 +14296,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other613) { - txn_ids = other613.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other619) { + txn_ids = other619.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other614) { - txn_ids = other614.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other620) { + txn_ids = other620.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -14230,6 +14319,11 @@ void CommitTxnRequest::__set_txnid(const int64_t val) { this->txnid = val; } +void CommitTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -14260,6 +14354,14 @@ uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -14283,6 +14385,11 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeI64(this->txnid); xfer += oprot->writeFieldEnd(); + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -14291,19 +14398,198 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c void swap(CommitTxnRequest &a, CommitTxnRequest &b) { using ::std::swap; swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.__isset, b.__isset); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other615) { - txnid = other615.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other621) { + txnid = other621.txnid; + replPolicy = other621.replPolicy; + __isset = other621.__isset; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other616) { - txnid = other616.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other622) { + txnid = other622.txnid; + replPolicy = other622.replPolicy; + __isset = other622.__isset; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "CommitTxnRequest("; out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ")"; +} + + +GetTargetTxnIdRequest::~GetTargetTxnIdRequest() throw() { +} + + +void GetTargetTxnIdRequest::__set_txnid(const int64_t val) { + this->txnid = val; +} + +uint32_t GetTargetTxnIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + isset_txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTargetTxnIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTargetTxnIdRequest"); + + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTargetTxnIdRequest &a, GetTargetTxnIdRequest &b) { + using ::std::swap; + swap(a.txnid, b.txnid); +} + +GetTargetTxnIdRequest::GetTargetTxnIdRequest(const GetTargetTxnIdRequest& other623) { + txnid = other623.txnid; +} +GetTargetTxnIdRequest& GetTargetTxnIdRequest::operator=(const GetTargetTxnIdRequest& other624) { + txnid = other624.txnid; + return *this; +} +void GetTargetTxnIdRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTargetTxnIdRequest("; + out << "txnid=" << to_string(txnid); + out << ")"; +} + + +GetTargetTxnIdResponse::~GetTargetTxnIdResponse() throw() { +} + + +void GetTargetTxnIdResponse::__set_txnid(const int64_t val) { + this->txnid = val; +} + +uint32_t GetTargetTxnIdResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + isset_txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTargetTxnIdResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTargetTxnIdResponse"); + + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTargetTxnIdResponse &a, GetTargetTxnIdResponse &b) { + using ::std::swap; + swap(a.txnid, b.txnid); +} + +GetTargetTxnIdResponse::GetTargetTxnIdResponse(const GetTargetTxnIdResponse& other625) { + txnid = other625.txnid; +} +GetTargetTxnIdResponse& GetTargetTxnIdResponse::operator=(const GetTargetTxnIdResponse& other626) { + txnid = other626.txnid; + return *this; +} +void GetTargetTxnIdResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTargetTxnIdResponse("; + out << "txnid=" << to_string(txnid); out << ")"; } @@ -14347,14 +14633,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fullTableNames.clear(); - uint32_t _size617; - ::apache::thrift::protocol::TType _etype620; - xfer += iprot->readListBegin(_etype620, _size617); - this->fullTableNames.resize(_size617); - uint32_t _i621; - for (_i621 = 0; _i621 < _size617; ++_i621) + uint32_t _size627; + ::apache::thrift::protocol::TType _etype630; + xfer += iprot->readListBegin(_etype630, _size627); + this->fullTableNames.resize(_size627); + uint32_t _i631; + for (_i631 = 0; _i631 < _size627; ++_i631) { - xfer += iprot->readString(this->fullTableNames[_i621]); + xfer += iprot->readString(this->fullTableNames[_i631]); } xfer += iprot->readListEnd(); } @@ -14395,10 +14681,10 @@ uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fullTableNames.size())); - std::vector ::const_iterator _iter622; - for (_iter622 = this->fullTableNames.begin(); _iter622 != this->fullTableNames.end(); ++_iter622) + std::vector ::const_iterator _iter632; + for (_iter632 = this->fullTableNames.begin(); _iter632 != this->fullTableNames.end(); ++_iter632) { - xfer += oprot->writeString((*_iter622)); + xfer += oprot->writeString((*_iter632)); } xfer += oprot->writeListEnd(); } @@ -14419,13 +14705,13 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) { swap(a.validTxnList, b.validTxnList); } -GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other623) { - fullTableNames = other623.fullTableNames; - validTxnList = other623.validTxnList; +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other633) { + fullTableNames = other633.fullTableNames; + validTxnList = other633.validTxnList; } -GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other624) { - fullTableNames = other624.fullTableNames; - validTxnList = other624.validTxnList; +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other634) { + fullTableNames = other634.fullTableNames; + validTxnList = other634.validTxnList; return *this; } void GetValidWriteIdsRequest::printTo(std::ostream& out) const { @@ -14507,14 +14793,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->invalidWriteIds.clear(); - uint32_t _size625; - ::apache::thrift::protocol::TType _etype628; - xfer += iprot->readListBegin(_etype628, _size625); - this->invalidWriteIds.resize(_size625); - uint32_t _i629; - for (_i629 = 0; _i629 < _size625; ++_i629) + uint32_t _size635; + ::apache::thrift::protocol::TType _etype638; + xfer += iprot->readListBegin(_etype638, _size635); + this->invalidWriteIds.resize(_size635); + uint32_t _i639; + for (_i639 = 0; _i639 < _size635; ++_i639) { - xfer += iprot->readI64(this->invalidWriteIds[_i629]); + xfer += iprot->readI64(this->invalidWriteIds[_i639]); } xfer += iprot->readListEnd(); } @@ -14575,10 +14861,10 @@ uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->invalidWriteIds.size())); - std::vector ::const_iterator _iter630; - for (_iter630 = this->invalidWriteIds.begin(); _iter630 != this->invalidWriteIds.end(); ++_iter630) + std::vector ::const_iterator _iter640; + for (_iter640 = this->invalidWriteIds.begin(); _iter640 != this->invalidWriteIds.end(); ++_iter640) { - xfer += oprot->writeI64((*_iter630)); + xfer += oprot->writeI64((*_iter640)); } xfer += oprot->writeListEnd(); } @@ -14608,21 +14894,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) { swap(a.__isset, b.__isset); } -TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other631) { - fullTableName = other631.fullTableName; - writeIdHighWaterMark = other631.writeIdHighWaterMark; - invalidWriteIds = other631.invalidWriteIds; - minOpenWriteId = other631.minOpenWriteId; - abortedBits = other631.abortedBits; - __isset = other631.__isset; -} -TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other632) { - fullTableName = other632.fullTableName; - writeIdHighWaterMark = other632.writeIdHighWaterMark; - invalidWriteIds = other632.invalidWriteIds; - minOpenWriteId = other632.minOpenWriteId; - abortedBits = other632.abortedBits; - __isset = other632.__isset; +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other641) { + fullTableName = other641.fullTableName; + writeIdHighWaterMark = other641.writeIdHighWaterMark; + invalidWriteIds = other641.invalidWriteIds; + minOpenWriteId = other641.minOpenWriteId; + abortedBits = other641.abortedBits; + __isset = other641.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other642) { + fullTableName = other642.fullTableName; + writeIdHighWaterMark = other642.writeIdHighWaterMark; + invalidWriteIds = other642.invalidWriteIds; + minOpenWriteId = other642.minOpenWriteId; + abortedBits = other642.abortedBits; + __isset = other642.__isset; return *this; } void TableValidWriteIds::printTo(std::ostream& out) const { @@ -14671,14 +14957,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblValidWriteIds.clear(); - uint32_t _size633; - ::apache::thrift::protocol::TType _etype636; - xfer += iprot->readListBegin(_etype636, _size633); - this->tblValidWriteIds.resize(_size633); - uint32_t _i637; - for (_i637 = 0; _i637 < _size633; ++_i637) + uint32_t _size643; + ::apache::thrift::protocol::TType _etype646; + xfer += iprot->readListBegin(_etype646, _size643); + this->tblValidWriteIds.resize(_size643); + uint32_t _i647; + for (_i647 = 0; _i647 < _size643; ++_i647) { - xfer += this->tblValidWriteIds[_i637].read(iprot); + xfer += this->tblValidWriteIds[_i647].read(iprot); } xfer += iprot->readListEnd(); } @@ -14709,10 +14995,10 @@ uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tblValidWriteIds.size())); - std::vector ::const_iterator _iter638; - for (_iter638 = this->tblValidWriteIds.begin(); _iter638 != this->tblValidWriteIds.end(); ++_iter638) + std::vector ::const_iterator _iter648; + for (_iter648 = this->tblValidWriteIds.begin(); _iter648 != this->tblValidWriteIds.end(); ++_iter648) { - xfer += (*_iter638).write(oprot); + xfer += (*_iter648).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14728,11 +15014,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) { swap(a.tblValidWriteIds, b.tblValidWriteIds); } -GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other639) { - tblValidWriteIds = other639.tblValidWriteIds; +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other649) { + tblValidWriteIds = other649.tblValidWriteIds; } -GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other640) { - tblValidWriteIds = other640.tblValidWriteIds; +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other650) { + tblValidWriteIds = other650.tblValidWriteIds; return *this; } void GetValidWriteIdsResponse::printTo(std::ostream& out) const { @@ -14787,14 +15073,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnIds.clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - this->txnIds.resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->txnIds.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) { - xfer += iprot->readI64(this->txnIds[_i645]); + xfer += iprot->readI64(this->txnIds[_i655]); } xfer += iprot->readListEnd(); } @@ -14845,10 +15131,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txnIds.size())); - std::vector ::const_iterator _iter646; - for (_iter646 = this->txnIds.begin(); _iter646 != this->txnIds.end(); ++_iter646) + std::vector ::const_iterator _iter656; + for (_iter656 = this->txnIds.begin(); _iter656 != this->txnIds.end(); ++_iter656) { - xfer += oprot->writeI64((*_iter646)); + xfer += oprot->writeI64((*_iter656)); } xfer += oprot->writeListEnd(); } @@ -14874,15 +15160,15 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) { swap(a.tableName, b.tableName); } -AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other647) { - txnIds = other647.txnIds; - dbName = other647.dbName; - tableName = other647.tableName; +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other657) { + txnIds = other657.txnIds; + dbName = other657.dbName; + tableName = other657.tableName; } -AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other648) { - txnIds = other648.txnIds; - dbName = other648.dbName; - tableName = other648.tableName; +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other658) { + txnIds = other658.txnIds; + dbName = other658.dbName; + tableName = other658.tableName; return *this; } void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { @@ -14986,13 +15272,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) { swap(a.writeId, b.writeId); } -TxnToWriteId::TxnToWriteId(const TxnToWriteId& other649) { - txnId = other649.txnId; - writeId = other649.writeId; +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other659) { + txnId = other659.txnId; + writeId = other659.writeId; } -TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other650) { - txnId = other650.txnId; - writeId = other650.writeId; +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other660) { + txnId = other660.txnId; + writeId = other660.writeId; return *this; } void TxnToWriteId::printTo(std::ostream& out) const { @@ -15038,14 +15324,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnToWriteIds.clear(); - uint32_t _size651; - ::apache::thrift::protocol::TType _etype654; - xfer += iprot->readListBegin(_etype654, _size651); - this->txnToWriteIds.resize(_size651); - uint32_t _i655; - for (_i655 = 0; _i655 < _size651; ++_i655) + uint32_t _size661; + ::apache::thrift::protocol::TType _etype664; + xfer += iprot->readListBegin(_etype664, _size661); + this->txnToWriteIds.resize(_size661); + uint32_t _i665; + for (_i665 = 0; _i665 < _size661; ++_i665) { - xfer += this->txnToWriteIds[_i655].read(iprot); + xfer += this->txnToWriteIds[_i665].read(iprot); } xfer += iprot->readListEnd(); } @@ -15076,10 +15362,10 @@ uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->txnToWriteIds.size())); - std::vector ::const_iterator _iter656; - for (_iter656 = this->txnToWriteIds.begin(); _iter656 != this->txnToWriteIds.end(); ++_iter656) + std::vector ::const_iterator _iter666; + for (_iter666 = this->txnToWriteIds.begin(); _iter666 != this->txnToWriteIds.end(); ++_iter666) { - xfer += (*_iter656).write(oprot); + xfer += (*_iter666).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15095,11 +15381,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) { swap(a.txnToWriteIds, b.txnToWriteIds); } -AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other657) { - txnToWriteIds = other657.txnToWriteIds; +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other667) { + txnToWriteIds = other667.txnToWriteIds; } -AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other658) { - txnToWriteIds = other658.txnToWriteIds; +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other668) { + txnToWriteIds = other668.txnToWriteIds; return *this; } void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { @@ -15177,9 +15463,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast659; - xfer += iprot->readI32(ecast659); - this->type = (LockType::type)ecast659; + int32_t ecast669; + xfer += iprot->readI32(ecast669); + this->type = (LockType::type)ecast669; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15187,9 +15473,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast660; - xfer += iprot->readI32(ecast660); - this->level = (LockLevel::type)ecast660; + int32_t ecast670; + xfer += iprot->readI32(ecast670); + this->level = (LockLevel::type)ecast670; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -15221,9 +15507,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast661; - xfer += iprot->readI32(ecast661); - this->operationType = (DataOperationType::type)ecast661; + int32_t ecast671; + xfer += iprot->readI32(ecast671); + this->operationType = (DataOperationType::type)ecast671; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15323,27 +15609,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other662) { - type = other662.type; - level = other662.level; - dbname = other662.dbname; - tablename = other662.tablename; - partitionname = other662.partitionname; - operationType = other662.operationType; - isAcid = other662.isAcid; - isDynamicPartitionWrite = other662.isDynamicPartitionWrite; - __isset = other662.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other663) { - type = other663.type; - level = other663.level; - dbname = other663.dbname; - tablename = other663.tablename; - partitionname = other663.partitionname; - operationType = other663.operationType; - isAcid = other663.isAcid; - isDynamicPartitionWrite = other663.isDynamicPartitionWrite; - __isset = other663.__isset; +LockComponent::LockComponent(const LockComponent& other672) { + type = other672.type; + level = other672.level; + dbname = other672.dbname; + tablename = other672.tablename; + partitionname = other672.partitionname; + operationType = other672.operationType; + isAcid = other672.isAcid; + isDynamicPartitionWrite = other672.isDynamicPartitionWrite; + __isset = other672.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other673) { + type = other673.type; + level = other673.level; + dbname = other673.dbname; + tablename = other673.tablename; + partitionname = other673.partitionname; + operationType = other673.operationType; + isAcid = other673.isAcid; + isDynamicPartitionWrite = other673.isDynamicPartitionWrite; + __isset = other673.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -15415,14 +15701,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size664; - ::apache::thrift::protocol::TType _etype667; - xfer += iprot->readListBegin(_etype667, _size664); - this->component.resize(_size664); - uint32_t _i668; - for (_i668 = 0; _i668 < _size664; ++_i668) + uint32_t _size674; + ::apache::thrift::protocol::TType _etype677; + xfer += iprot->readListBegin(_etype677, _size674); + this->component.resize(_size674); + uint32_t _i678; + for (_i678 = 0; _i678 < _size674; ++_i678) { - xfer += this->component[_i668].read(iprot); + xfer += this->component[_i678].read(iprot); } xfer += iprot->readListEnd(); } @@ -15489,10 +15775,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 _iter669; - for (_iter669 = this->component.begin(); _iter669 != this->component.end(); ++_iter669) + std::vector ::const_iterator _iter679; + for (_iter679 = this->component.begin(); _iter679 != this->component.end(); ++_iter679) { - xfer += (*_iter669).write(oprot); + xfer += (*_iter679).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15531,21 +15817,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other670) { - component = other670.component; - txnid = other670.txnid; - user = other670.user; - hostname = other670.hostname; - agentInfo = other670.agentInfo; - __isset = other670.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other671) { - component = other671.component; - txnid = other671.txnid; - user = other671.user; - hostname = other671.hostname; - agentInfo = other671.agentInfo; - __isset = other671.__isset; +LockRequest::LockRequest(const LockRequest& other680) { + component = other680.component; + txnid = other680.txnid; + user = other680.user; + hostname = other680.hostname; + agentInfo = other680.agentInfo; + __isset = other680.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other681) { + component = other681.component; + txnid = other681.txnid; + user = other681.user; + hostname = other681.hostname; + agentInfo = other681.agentInfo; + __isset = other681.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -15605,9 +15891,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast672; - xfer += iprot->readI32(ecast672); - this->state = (LockState::type)ecast672; + int32_t ecast682; + xfer += iprot->readI32(ecast682); + this->state = (LockState::type)ecast682; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -15653,13 +15939,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other673) { - lockid = other673.lockid; - state = other673.state; +LockResponse::LockResponse(const LockResponse& other683) { + lockid = other683.lockid; + state = other683.state; } -LockResponse& LockResponse::operator=(const LockResponse& other674) { - lockid = other674.lockid; - state = other674.state; +LockResponse& LockResponse::operator=(const LockResponse& other684) { + lockid = other684.lockid; + state = other684.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -15781,17 +16067,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other675) { - lockid = other675.lockid; - txnid = other675.txnid; - elapsed_ms = other675.elapsed_ms; - __isset = other675.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other685) { + lockid = other685.lockid; + txnid = other685.txnid; + elapsed_ms = other685.elapsed_ms; + __isset = other685.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other676) { - lockid = other676.lockid; - txnid = other676.txnid; - elapsed_ms = other676.elapsed_ms; - __isset = other676.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other686) { + lockid = other686.lockid; + txnid = other686.txnid; + elapsed_ms = other686.elapsed_ms; + __isset = other686.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -15875,11 +16161,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other677) { - lockid = other677.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other687) { + lockid = other687.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other678) { - lockid = other678.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other688) { + lockid = other688.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -16018,19 +16304,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other679) { - dbname = other679.dbname; - tablename = other679.tablename; - partname = other679.partname; - isExtended = other679.isExtended; - __isset = other679.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other689) { + dbname = other689.dbname; + tablename = other689.tablename; + partname = other689.partname; + isExtended = other689.isExtended; + __isset = other689.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other680) { - dbname = other680.dbname; - tablename = other680.tablename; - partname = other680.partname; - isExtended = other680.isExtended; - __isset = other680.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other690) { + dbname = other690.dbname; + tablename = other690.tablename; + partname = other690.partname; + isExtended = other690.isExtended; + __isset = other690.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -16183,9 +16469,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast681; - xfer += iprot->readI32(ecast681); - this->state = (LockState::type)ecast681; + int32_t ecast691; + xfer += iprot->readI32(ecast691); + this->state = (LockState::type)ecast691; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -16193,9 +16479,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast682; - xfer += iprot->readI32(ecast682); - this->type = (LockType::type)ecast682; + int32_t ecast692; + xfer += iprot->readI32(ecast692); + this->type = (LockType::type)ecast692; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -16411,43 +16697,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other683) { - lockid = other683.lockid; - dbname = other683.dbname; - tablename = other683.tablename; - partname = other683.partname; - state = other683.state; - type = other683.type; - txnid = other683.txnid; - lastheartbeat = other683.lastheartbeat; - acquiredat = other683.acquiredat; - user = other683.user; - hostname = other683.hostname; - heartbeatCount = other683.heartbeatCount; - agentInfo = other683.agentInfo; - blockedByExtId = other683.blockedByExtId; - blockedByIntId = other683.blockedByIntId; - lockIdInternal = other683.lockIdInternal; - __isset = other683.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other684) { - lockid = other684.lockid; - dbname = other684.dbname; - tablename = other684.tablename; - partname = other684.partname; - state = other684.state; - type = other684.type; - txnid = other684.txnid; - lastheartbeat = other684.lastheartbeat; - acquiredat = other684.acquiredat; - user = other684.user; - hostname = other684.hostname; - heartbeatCount = other684.heartbeatCount; - agentInfo = other684.agentInfo; - blockedByExtId = other684.blockedByExtId; - blockedByIntId = other684.blockedByIntId; - lockIdInternal = other684.lockIdInternal; - __isset = other684.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other693) { + lockid = other693.lockid; + dbname = other693.dbname; + tablename = other693.tablename; + partname = other693.partname; + state = other693.state; + type = other693.type; + txnid = other693.txnid; + lastheartbeat = other693.lastheartbeat; + acquiredat = other693.acquiredat; + user = other693.user; + hostname = other693.hostname; + heartbeatCount = other693.heartbeatCount; + agentInfo = other693.agentInfo; + blockedByExtId = other693.blockedByExtId; + blockedByIntId = other693.blockedByIntId; + lockIdInternal = other693.lockIdInternal; + __isset = other693.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other694) { + lockid = other694.lockid; + dbname = other694.dbname; + tablename = other694.tablename; + partname = other694.partname; + state = other694.state; + type = other694.type; + txnid = other694.txnid; + lastheartbeat = other694.lastheartbeat; + acquiredat = other694.acquiredat; + user = other694.user; + hostname = other694.hostname; + heartbeatCount = other694.heartbeatCount; + agentInfo = other694.agentInfo; + blockedByExtId = other694.blockedByExtId; + blockedByIntId = other694.blockedByIntId; + lockIdInternal = other694.lockIdInternal; + __isset = other694.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -16506,14 +16792,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size685; - ::apache::thrift::protocol::TType _etype688; - xfer += iprot->readListBegin(_etype688, _size685); - this->locks.resize(_size685); - uint32_t _i689; - for (_i689 = 0; _i689 < _size685; ++_i689) + uint32_t _size695; + ::apache::thrift::protocol::TType _etype698; + xfer += iprot->readListBegin(_etype698, _size695); + this->locks.resize(_size695); + uint32_t _i699; + for (_i699 = 0; _i699 < _size695; ++_i699) { - xfer += this->locks[_i689].read(iprot); + xfer += this->locks[_i699].read(iprot); } xfer += iprot->readListEnd(); } @@ -16542,10 +16828,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 _iter690; - for (_iter690 = this->locks.begin(); _iter690 != this->locks.end(); ++_iter690) + std::vector ::const_iterator _iter700; + for (_iter700 = this->locks.begin(); _iter700 != this->locks.end(); ++_iter700) { - xfer += (*_iter690).write(oprot); + xfer += (*_iter700).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16562,13 +16848,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other691) { - locks = other691.locks; - __isset = other691.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other701) { + locks = other701.locks; + __isset = other701.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other692) { - locks = other692.locks; - __isset = other692.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other702) { + locks = other702.locks; + __isset = other702.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -16669,15 +16955,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other693) { - lockid = other693.lockid; - txnid = other693.txnid; - __isset = other693.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other703) { + lockid = other703.lockid; + txnid = other703.txnid; + __isset = other703.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other694) { - lockid = other694.lockid; - txnid = other694.txnid; - __isset = other694.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other704) { + lockid = other704.lockid; + txnid = other704.txnid; + __isset = other704.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -16780,13 +17066,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other695) { - min = other695.min; - max = other695.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other705) { + min = other705.min; + max = other705.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other696) { - min = other696.min; - max = other696.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other706) { + min = other706.min; + max = other706.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -16837,15 +17123,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size697; - ::apache::thrift::protocol::TType _etype700; - xfer += iprot->readSetBegin(_etype700, _size697); - uint32_t _i701; - for (_i701 = 0; _i701 < _size697; ++_i701) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readSetBegin(_etype710, _size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - int64_t _elem702; - xfer += iprot->readI64(_elem702); - this->aborted.insert(_elem702); + int64_t _elem712; + xfer += iprot->readI64(_elem712); + this->aborted.insert(_elem712); } xfer += iprot->readSetEnd(); } @@ -16858,15 +17144,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size703; - ::apache::thrift::protocol::TType _etype706; - xfer += iprot->readSetBegin(_etype706, _size703); - uint32_t _i707; - for (_i707 = 0; _i707 < _size703; ++_i707) + uint32_t _size713; + ::apache::thrift::protocol::TType _etype716; + xfer += iprot->readSetBegin(_etype716, _size713); + uint32_t _i717; + for (_i717 = 0; _i717 < _size713; ++_i717) { - int64_t _elem708; - xfer += iprot->readI64(_elem708); - this->nosuch.insert(_elem708); + int64_t _elem718; + xfer += iprot->readI64(_elem718); + this->nosuch.insert(_elem718); } xfer += iprot->readSetEnd(); } @@ -16899,10 +17185,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 _iter709; - for (_iter709 = this->aborted.begin(); _iter709 != this->aborted.end(); ++_iter709) + std::set ::const_iterator _iter719; + for (_iter719 = this->aborted.begin(); _iter719 != this->aborted.end(); ++_iter719) { - xfer += oprot->writeI64((*_iter709)); + xfer += oprot->writeI64((*_iter719)); } xfer += oprot->writeSetEnd(); } @@ -16911,10 +17197,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 _iter710; - for (_iter710 = this->nosuch.begin(); _iter710 != this->nosuch.end(); ++_iter710) + std::set ::const_iterator _iter720; + for (_iter720 = this->nosuch.begin(); _iter720 != this->nosuch.end(); ++_iter720) { - xfer += oprot->writeI64((*_iter710)); + xfer += oprot->writeI64((*_iter720)); } xfer += oprot->writeSetEnd(); } @@ -16931,13 +17217,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other711) { - aborted = other711.aborted; - nosuch = other711.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other721) { + aborted = other721.aborted; + nosuch = other721.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other712) { - aborted = other712.aborted; - nosuch = other712.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other722) { + aborted = other722.aborted; + nosuch = other722.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -17030,9 +17316,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast713; - xfer += iprot->readI32(ecast713); - this->type = (CompactionType::type)ecast713; + int32_t ecast723; + xfer += iprot->readI32(ecast723); + this->type = (CompactionType::type)ecast723; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -17050,17 +17336,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size714; - ::apache::thrift::protocol::TType _ktype715; - ::apache::thrift::protocol::TType _vtype716; - xfer += iprot->readMapBegin(_ktype715, _vtype716, _size714); - uint32_t _i718; - for (_i718 = 0; _i718 < _size714; ++_i718) + uint32_t _size724; + ::apache::thrift::protocol::TType _ktype725; + ::apache::thrift::protocol::TType _vtype726; + xfer += iprot->readMapBegin(_ktype725, _vtype726, _size724); + uint32_t _i728; + for (_i728 = 0; _i728 < _size724; ++_i728) { - std::string _key719; - xfer += iprot->readString(_key719); - std::string& _val720 = this->properties[_key719]; - xfer += iprot->readString(_val720); + std::string _key729; + xfer += iprot->readString(_key729); + std::string& _val730 = this->properties[_key729]; + xfer += iprot->readString(_val730); } xfer += iprot->readMapEnd(); } @@ -17118,11 +17404,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 _iter721; - for (_iter721 = this->properties.begin(); _iter721 != this->properties.end(); ++_iter721) + std::map ::const_iterator _iter731; + for (_iter731 = this->properties.begin(); _iter731 != this->properties.end(); ++_iter731) { - xfer += oprot->writeString(_iter721->first); - xfer += oprot->writeString(_iter721->second); + xfer += oprot->writeString(_iter731->first); + xfer += oprot->writeString(_iter731->second); } xfer += oprot->writeMapEnd(); } @@ -17144,23 +17430,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other722) { - dbname = other722.dbname; - tablename = other722.tablename; - partitionname = other722.partitionname; - type = other722.type; - runas = other722.runas; - properties = other722.properties; - __isset = other722.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other723) { - dbname = other723.dbname; - tablename = other723.tablename; - partitionname = other723.partitionname; - type = other723.type; - runas = other723.runas; - properties = other723.properties; - __isset = other723.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other732) { + dbname = other732.dbname; + tablename = other732.tablename; + partitionname = other732.partitionname; + type = other732.type; + runas = other732.runas; + properties = other732.properties; + __isset = other732.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other733) { + dbname = other733.dbname; + tablename = other733.tablename; + partitionname = other733.partitionname; + type = other733.type; + runas = other733.runas; + properties = other733.properties; + __isset = other733.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -17287,15 +17573,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other724) { - id = other724.id; - state = other724.state; - accepted = other724.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other734) { + id = other734.id; + state = other734.state; + accepted = other734.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other725) { - id = other725.id; - state = other725.state; - accepted = other725.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other735) { + id = other735.id; + state = other735.state; + accepted = other735.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -17356,11 +17642,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other726) { - (void) other726; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other736) { + (void) other736; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other727) { - (void) other727; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other737) { + (void) other737; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -17486,9 +17772,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast728; - xfer += iprot->readI32(ecast728); - this->type = (CompactionType::type)ecast728; + int32_t ecast738; + xfer += iprot->readI32(ecast738); + this->type = (CompactionType::type)ecast738; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -17675,37 +17961,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other729) { - dbname = other729.dbname; - tablename = other729.tablename; - partitionname = other729.partitionname; - type = other729.type; - state = other729.state; - workerid = other729.workerid; - start = other729.start; - runAs = other729.runAs; - hightestTxnId = other729.hightestTxnId; - metaInfo = other729.metaInfo; - endTime = other729.endTime; - hadoopJobId = other729.hadoopJobId; - id = other729.id; - __isset = other729.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other730) { - dbname = other730.dbname; - tablename = other730.tablename; - partitionname = other730.partitionname; - type = other730.type; - state = other730.state; - workerid = other730.workerid; - start = other730.start; - runAs = other730.runAs; - hightestTxnId = other730.hightestTxnId; - metaInfo = other730.metaInfo; - endTime = other730.endTime; - hadoopJobId = other730.hadoopJobId; - id = other730.id; - __isset = other730.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other739) { + dbname = other739.dbname; + tablename = other739.tablename; + partitionname = other739.partitionname; + type = other739.type; + state = other739.state; + workerid = other739.workerid; + start = other739.start; + runAs = other739.runAs; + hightestTxnId = other739.hightestTxnId; + metaInfo = other739.metaInfo; + endTime = other739.endTime; + hadoopJobId = other739.hadoopJobId; + id = other739.id; + __isset = other739.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other740) { + dbname = other740.dbname; + tablename = other740.tablename; + partitionname = other740.partitionname; + type = other740.type; + state = other740.state; + workerid = other740.workerid; + start = other740.start; + runAs = other740.runAs; + hightestTxnId = other740.hightestTxnId; + metaInfo = other740.metaInfo; + endTime = other740.endTime; + hadoopJobId = other740.hadoopJobId; + id = other740.id; + __isset = other740.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -17762,14 +18048,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size731; - ::apache::thrift::protocol::TType _etype734; - xfer += iprot->readListBegin(_etype734, _size731); - this->compacts.resize(_size731); - uint32_t _i735; - for (_i735 = 0; _i735 < _size731; ++_i735) + uint32_t _size741; + ::apache::thrift::protocol::TType _etype744; + xfer += iprot->readListBegin(_etype744, _size741); + this->compacts.resize(_size741); + uint32_t _i745; + for (_i745 = 0; _i745 < _size741; ++_i745) { - xfer += this->compacts[_i735].read(iprot); + xfer += this->compacts[_i745].read(iprot); } xfer += iprot->readListEnd(); } @@ -17800,10 +18086,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 _iter736; - for (_iter736 = this->compacts.begin(); _iter736 != this->compacts.end(); ++_iter736) + std::vector ::const_iterator _iter746; + for (_iter746 = this->compacts.begin(); _iter746 != this->compacts.end(); ++_iter746) { - xfer += (*_iter736).write(oprot); + xfer += (*_iter746).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17819,11 +18105,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other737) { - compacts = other737.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other747) { + compacts = other747.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other738) { - compacts = other738.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other748) { + compacts = other748.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -17925,14 +18211,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size739; - ::apache::thrift::protocol::TType _etype742; - xfer += iprot->readListBegin(_etype742, _size739); - this->partitionnames.resize(_size739); - uint32_t _i743; - for (_i743 = 0; _i743 < _size739; ++_i743) + uint32_t _size749; + ::apache::thrift::protocol::TType _etype752; + xfer += iprot->readListBegin(_etype752, _size749); + this->partitionnames.resize(_size749); + uint32_t _i753; + for (_i753 = 0; _i753 < _size749; ++_i753) { - xfer += iprot->readString(this->partitionnames[_i743]); + xfer += iprot->readString(this->partitionnames[_i753]); } xfer += iprot->readListEnd(); } @@ -17943,9 +18229,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast744; - xfer += iprot->readI32(ecast744); - this->operationType = (DataOperationType::type)ecast744; + int32_t ecast754; + xfer += iprot->readI32(ecast754); + this->operationType = (DataOperationType::type)ecast754; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -17997,10 +18283,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter745; - for (_iter745 = this->partitionnames.begin(); _iter745 != this->partitionnames.end(); ++_iter745) + std::vector ::const_iterator _iter755; + for (_iter755 = this->partitionnames.begin(); _iter755 != this->partitionnames.end(); ++_iter755) { - xfer += oprot->writeString((*_iter745)); + xfer += oprot->writeString((*_iter755)); } xfer += oprot->writeListEnd(); } @@ -18027,23 +18313,23 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other746) { - txnid = other746.txnid; - writeid = other746.writeid; - dbname = other746.dbname; - tablename = other746.tablename; - partitionnames = other746.partitionnames; - operationType = other746.operationType; - __isset = other746.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other747) { - txnid = other747.txnid; - writeid = other747.writeid; - dbname = other747.dbname; - tablename = other747.tablename; - partitionnames = other747.partitionnames; - operationType = other747.operationType; - __isset = other747.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other756) { + txnid = other756.txnid; + writeid = other756.writeid; + dbname = other756.dbname; + tablename = other756.tablename; + partitionnames = other756.partitionnames; + operationType = other756.operationType; + __isset = other756.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other757) { + txnid = other757.txnid; + writeid = other757.writeid; + dbname = other757.dbname; + tablename = other757.tablename; + partitionnames = other757.partitionnames; + operationType = other757.operationType; + __isset = other757.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -18226,23 +18512,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) { swap(a.__isset, b.__isset); } -BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other748) { - isnull = other748.isnull; - time = other748.time; - txnid = other748.txnid; - dbname = other748.dbname; - tablename = other748.tablename; - partitionname = other748.partitionname; - __isset = other748.__isset; -} -BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other749) { - isnull = other749.isnull; - time = other749.time; - txnid = other749.txnid; - dbname = other749.dbname; - tablename = other749.tablename; - partitionname = other749.partitionname; - __isset = other749.__isset; +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other758) { + isnull = other758.isnull; + time = other758.time; + txnid = other758.txnid; + dbname = other758.dbname; + tablename = other758.tablename; + partitionname = other758.partitionname; + __isset = other758.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other759) { + isnull = other759.isnull; + time = other759.time; + txnid = other759.txnid; + dbname = other759.dbname; + tablename = other759.tablename; + partitionname = other759.partitionname; + __isset = other759.__isset; return *this; } void BasicTxnInfo::printTo(std::ostream& out) const { @@ -18323,15 +18609,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size750; - ::apache::thrift::protocol::TType _etype753; - xfer += iprot->readSetBegin(_etype753, _size750); - uint32_t _i754; - for (_i754 = 0; _i754 < _size750; ++_i754) + uint32_t _size760; + ::apache::thrift::protocol::TType _etype763; + xfer += iprot->readSetBegin(_etype763, _size760); + uint32_t _i764; + for (_i764 = 0; _i764 < _size760; ++_i764) { - std::string _elem755; - xfer += iprot->readString(_elem755); - this->tablesUsed.insert(_elem755); + std::string _elem765; + xfer += iprot->readString(_elem765); + this->tablesUsed.insert(_elem765); } xfer += iprot->readSetEnd(); } @@ -18382,10 +18668,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 3); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); - std::set ::const_iterator _iter756; - for (_iter756 = this->tablesUsed.begin(); _iter756 != this->tablesUsed.end(); ++_iter756) + std::set ::const_iterator _iter766; + for (_iter766 = this->tablesUsed.begin(); _iter766 != this->tablesUsed.end(); ++_iter766) { - xfer += oprot->writeString((*_iter756)); + xfer += oprot->writeString((*_iter766)); } xfer += oprot->writeSetEnd(); } @@ -18410,19 +18696,19 @@ void swap(CreationMetadata &a, CreationMetadata &b) { swap(a.__isset, b.__isset); } -CreationMetadata::CreationMetadata(const CreationMetadata& other757) { - dbName = other757.dbName; - tblName = other757.tblName; - tablesUsed = other757.tablesUsed; - validTxnList = other757.validTxnList; - __isset = other757.__isset; +CreationMetadata::CreationMetadata(const CreationMetadata& other767) { + dbName = other767.dbName; + tblName = other767.tblName; + tablesUsed = other767.tablesUsed; + validTxnList = other767.validTxnList; + __isset = other767.__isset; } -CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other758) { - dbName = other758.dbName; - tblName = other758.tblName; - tablesUsed = other758.tablesUsed; - validTxnList = other758.validTxnList; - __isset = other758.__isset; +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other768) { + dbName = other768.dbName; + tblName = other768.tblName; + tablesUsed = other768.tablesUsed; + validTxnList = other768.validTxnList; + __isset = other768.__isset; return *this; } void CreationMetadata::printTo(std::ostream& out) const { @@ -18527,15 +18813,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other759) { - lastEvent = other759.lastEvent; - maxEvents = other759.maxEvents; - __isset = other759.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other769) { + lastEvent = other769.lastEvent; + maxEvents = other769.maxEvents; + __isset = other769.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other760) { - lastEvent = other760.lastEvent; - maxEvents = other760.maxEvents; - __isset = other760.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other770) { + lastEvent = other770.lastEvent; + maxEvents = other770.maxEvents; + __isset = other770.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -18736,25 +19022,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other761) { - eventId = other761.eventId; - eventTime = other761.eventTime; - eventType = other761.eventType; - dbName = other761.dbName; - tableName = other761.tableName; - message = other761.message; - messageFormat = other761.messageFormat; - __isset = other761.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other762) { - eventId = other762.eventId; - eventTime = other762.eventTime; - eventType = other762.eventType; - dbName = other762.dbName; - tableName = other762.tableName; - message = other762.message; - messageFormat = other762.messageFormat; - __isset = other762.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other771) { + eventId = other771.eventId; + eventTime = other771.eventTime; + eventType = other771.eventType; + dbName = other771.dbName; + tableName = other771.tableName; + message = other771.message; + messageFormat = other771.messageFormat; + __isset = other771.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other772) { + eventId = other772.eventId; + eventTime = other772.eventTime; + eventType = other772.eventType; + dbName = other772.dbName; + tableName = other772.tableName; + message = other772.message; + messageFormat = other772.messageFormat; + __isset = other772.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -18805,14 +19091,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size763; - ::apache::thrift::protocol::TType _etype766; - xfer += iprot->readListBegin(_etype766, _size763); - this->events.resize(_size763); - uint32_t _i767; - for (_i767 = 0; _i767 < _size763; ++_i767) + uint32_t _size773; + ::apache::thrift::protocol::TType _etype776; + xfer += iprot->readListBegin(_etype776, _size773); + this->events.resize(_size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - xfer += this->events[_i767].read(iprot); + xfer += this->events[_i777].read(iprot); } xfer += iprot->readListEnd(); } @@ -18843,10 +19129,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 _iter768; - for (_iter768 = this->events.begin(); _iter768 != this->events.end(); ++_iter768) + std::vector ::const_iterator _iter778; + for (_iter778 = this->events.begin(); _iter778 != this->events.end(); ++_iter778) { - xfer += (*_iter768).write(oprot); + xfer += (*_iter778).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18862,11 +19148,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other769) { - events = other769.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other779) { + events = other779.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other770) { - events = other770.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other780) { + events = other780.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -18948,11 +19234,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other771) { - eventId = other771.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other781) { + eventId = other781.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other772) { - eventId = other772.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other782) { + eventId = other782.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -19054,13 +19340,13 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.dbName, b.dbName); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other773) { - fromEventId = other773.fromEventId; - dbName = other773.dbName; +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other783) { + fromEventId = other783.fromEventId; + dbName = other783.dbName; } -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other774) { - fromEventId = other774.fromEventId; - dbName = other774.dbName; +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other784) { + fromEventId = other784.fromEventId; + dbName = other784.dbName; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -19143,11 +19429,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other775) { - eventsCount = other775.eventsCount; +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other785) { + eventsCount = other785.eventsCount; } -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other776) { - eventsCount = other776.eventsCount; +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other786) { + eventsCount = other786.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -19210,14 +19496,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size777; - ::apache::thrift::protocol::TType _etype780; - xfer += iprot->readListBegin(_etype780, _size777); - this->filesAdded.resize(_size777); - uint32_t _i781; - for (_i781 = 0; _i781 < _size777; ++_i781) + uint32_t _size787; + ::apache::thrift::protocol::TType _etype790; + xfer += iprot->readListBegin(_etype790, _size787); + this->filesAdded.resize(_size787); + uint32_t _i791; + for (_i791 = 0; _i791 < _size787; ++_i791) { - xfer += iprot->readString(this->filesAdded[_i781]); + xfer += iprot->readString(this->filesAdded[_i791]); } xfer += iprot->readListEnd(); } @@ -19230,14 +19516,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size782; - ::apache::thrift::protocol::TType _etype785; - xfer += iprot->readListBegin(_etype785, _size782); - this->filesAddedChecksum.resize(_size782); - uint32_t _i786; - for (_i786 = 0; _i786 < _size782; ++_i786) + uint32_t _size792; + ::apache::thrift::protocol::TType _etype795; + xfer += iprot->readListBegin(_etype795, _size792); + this->filesAddedChecksum.resize(_size792); + uint32_t _i796; + for (_i796 = 0; _i796 < _size792; ++_i796) { - xfer += iprot->readString(this->filesAddedChecksum[_i786]); + xfer += iprot->readString(this->filesAddedChecksum[_i796]); } xfer += iprot->readListEnd(); } @@ -19273,10 +19559,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 _iter787; - for (_iter787 = this->filesAdded.begin(); _iter787 != this->filesAdded.end(); ++_iter787) + std::vector ::const_iterator _iter797; + for (_iter797 = this->filesAdded.begin(); _iter797 != this->filesAdded.end(); ++_iter797) { - xfer += oprot->writeString((*_iter787)); + xfer += oprot->writeString((*_iter797)); } xfer += oprot->writeListEnd(); } @@ -19286,10 +19572,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 _iter788; - for (_iter788 = this->filesAddedChecksum.begin(); _iter788 != this->filesAddedChecksum.end(); ++_iter788) + std::vector ::const_iterator _iter798; + for (_iter798 = this->filesAddedChecksum.begin(); _iter798 != this->filesAddedChecksum.end(); ++_iter798) { - xfer += oprot->writeString((*_iter788)); + xfer += oprot->writeString((*_iter798)); } xfer += oprot->writeListEnd(); } @@ -19308,17 +19594,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other789) { - replace = other789.replace; - filesAdded = other789.filesAdded; - filesAddedChecksum = other789.filesAddedChecksum; - __isset = other789.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other799) { + replace = other799.replace; + filesAdded = other799.filesAdded; + filesAddedChecksum = other799.filesAddedChecksum; + __isset = other799.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other790) { - replace = other790.replace; - filesAdded = other790.filesAdded; - filesAddedChecksum = other790.filesAddedChecksum; - __isset = other790.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other800) { + replace = other800.replace; + filesAdded = other800.filesAdded; + filesAddedChecksum = other800.filesAddedChecksum; + __isset = other800.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -19400,13 +19686,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other791) { - insertData = other791.insertData; - __isset = other791.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other801) { + insertData = other801.insertData; + __isset = other801.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other792) { - insertData = other792.insertData; - __isset = other792.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other802) { + insertData = other802.insertData; + __isset = other802.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -19503,14 +19789,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size793; - ::apache::thrift::protocol::TType _etype796; - xfer += iprot->readListBegin(_etype796, _size793); - this->partitionVals.resize(_size793); - uint32_t _i797; - for (_i797 = 0; _i797 < _size793; ++_i797) + uint32_t _size803; + ::apache::thrift::protocol::TType _etype806; + xfer += iprot->readListBegin(_etype806, _size803); + this->partitionVals.resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += iprot->readString(this->partitionVals[_i797]); + xfer += iprot->readString(this->partitionVals[_i807]); } xfer += iprot->readListEnd(); } @@ -19562,10 +19848,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 _iter798; - for (_iter798 = this->partitionVals.begin(); _iter798 != this->partitionVals.end(); ++_iter798) + std::vector ::const_iterator _iter808; + for (_iter808 = this->partitionVals.begin(); _iter808 != this->partitionVals.end(); ++_iter808) { - xfer += oprot->writeString((*_iter798)); + xfer += oprot->writeString((*_iter808)); } xfer += oprot->writeListEnd(); } @@ -19586,21 +19872,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other799) { - successful = other799.successful; - data = other799.data; - dbName = other799.dbName; - tableName = other799.tableName; - partitionVals = other799.partitionVals; - __isset = other799.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other800) { - successful = other800.successful; - data = other800.data; - dbName = other800.dbName; - tableName = other800.tableName; - partitionVals = other800.partitionVals; - __isset = other800.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other809) { + successful = other809.successful; + data = other809.data; + dbName = other809.dbName; + tableName = other809.tableName; + partitionVals = other809.partitionVals; + __isset = other809.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other810) { + successful = other810.successful; + data = other810.data; + dbName = other810.dbName; + tableName = other810.tableName; + partitionVals = other810.partitionVals; + __isset = other810.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -19663,11 +19949,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other801) { - (void) other801; +FireEventResponse::FireEventResponse(const FireEventResponse& other811) { + (void) other811; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other802) { - (void) other802; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other812) { + (void) other812; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -19767,15 +20053,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other803) { - metadata = other803.metadata; - includeBitset = other803.includeBitset; - __isset = other803.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other813) { + metadata = other813.metadata; + includeBitset = other813.includeBitset; + __isset = other813.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other804) { - metadata = other804.metadata; - includeBitset = other804.includeBitset; - __isset = other804.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other814) { + metadata = other814.metadata; + includeBitset = other814.includeBitset; + __isset = other814.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -19826,17 +20112,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size805; - ::apache::thrift::protocol::TType _ktype806; - ::apache::thrift::protocol::TType _vtype807; - xfer += iprot->readMapBegin(_ktype806, _vtype807, _size805); - uint32_t _i809; - for (_i809 = 0; _i809 < _size805; ++_i809) + uint32_t _size815; + ::apache::thrift::protocol::TType _ktype816; + ::apache::thrift::protocol::TType _vtype817; + xfer += iprot->readMapBegin(_ktype816, _vtype817, _size815); + uint32_t _i819; + for (_i819 = 0; _i819 < _size815; ++_i819) { - int64_t _key810; - xfer += iprot->readI64(_key810); - MetadataPpdResult& _val811 = this->metadata[_key810]; - xfer += _val811.read(iprot); + int64_t _key820; + xfer += iprot->readI64(_key820); + MetadataPpdResult& _val821 = this->metadata[_key820]; + xfer += _val821.read(iprot); } xfer += iprot->readMapEnd(); } @@ -19877,11 +20163,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 _iter812; - for (_iter812 = this->metadata.begin(); _iter812 != this->metadata.end(); ++_iter812) + std::map ::const_iterator _iter822; + for (_iter822 = this->metadata.begin(); _iter822 != this->metadata.end(); ++_iter822) { - xfer += oprot->writeI64(_iter812->first); - xfer += _iter812->second.write(oprot); + xfer += oprot->writeI64(_iter822->first); + xfer += _iter822->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -19902,13 +20188,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other813) { - metadata = other813.metadata; - isSupported = other813.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other823) { + metadata = other823.metadata; + isSupported = other823.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other814) { - metadata = other814.metadata; - isSupported = other814.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other824) { + metadata = other824.metadata; + isSupported = other824.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -19969,14 +20255,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size815; - ::apache::thrift::protocol::TType _etype818; - xfer += iprot->readListBegin(_etype818, _size815); - this->fileIds.resize(_size815); - uint32_t _i819; - for (_i819 = 0; _i819 < _size815; ++_i819) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + this->fileIds.resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += iprot->readI64(this->fileIds[_i819]); + xfer += iprot->readI64(this->fileIds[_i829]); } xfer += iprot->readListEnd(); } @@ -20003,9 +20289,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast820; - xfer += iprot->readI32(ecast820); - this->type = (FileMetadataExprType::type)ecast820; + int32_t ecast830; + xfer += iprot->readI32(ecast830); + this->type = (FileMetadataExprType::type)ecast830; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -20035,10 +20321,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 _iter821; - for (_iter821 = this->fileIds.begin(); _iter821 != this->fileIds.end(); ++_iter821) + std::vector ::const_iterator _iter831; + for (_iter831 = this->fileIds.begin(); _iter831 != this->fileIds.end(); ++_iter831) { - xfer += oprot->writeI64((*_iter821)); + xfer += oprot->writeI64((*_iter831)); } xfer += oprot->writeListEnd(); } @@ -20072,19 +20358,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other822) { - fileIds = other822.fileIds; - expr = other822.expr; - doGetFooters = other822.doGetFooters; - type = other822.type; - __isset = other822.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other832) { + fileIds = other832.fileIds; + expr = other832.expr; + doGetFooters = other832.doGetFooters; + type = other832.type; + __isset = other832.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other823) { - fileIds = other823.fileIds; - expr = other823.expr; - doGetFooters = other823.doGetFooters; - type = other823.type; - __isset = other823.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other833) { + fileIds = other833.fileIds; + expr = other833.expr; + doGetFooters = other833.doGetFooters; + type = other833.type; + __isset = other833.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -20137,17 +20423,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size824; - ::apache::thrift::protocol::TType _ktype825; - ::apache::thrift::protocol::TType _vtype826; - xfer += iprot->readMapBegin(_ktype825, _vtype826, _size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + uint32_t _size834; + ::apache::thrift::protocol::TType _ktype835; + ::apache::thrift::protocol::TType _vtype836; + xfer += iprot->readMapBegin(_ktype835, _vtype836, _size834); + uint32_t _i838; + for (_i838 = 0; _i838 < _size834; ++_i838) { - int64_t _key829; - xfer += iprot->readI64(_key829); - std::string& _val830 = this->metadata[_key829]; - xfer += iprot->readBinary(_val830); + int64_t _key839; + xfer += iprot->readI64(_key839); + std::string& _val840 = this->metadata[_key839]; + xfer += iprot->readBinary(_val840); } xfer += iprot->readMapEnd(); } @@ -20188,11 +20474,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 _iter831; - for (_iter831 = this->metadata.begin(); _iter831 != this->metadata.end(); ++_iter831) + std::map ::const_iterator _iter841; + for (_iter841 = this->metadata.begin(); _iter841 != this->metadata.end(); ++_iter841) { - xfer += oprot->writeI64(_iter831->first); - xfer += oprot->writeBinary(_iter831->second); + xfer += oprot->writeI64(_iter841->first); + xfer += oprot->writeBinary(_iter841->second); } xfer += oprot->writeMapEnd(); } @@ -20213,13 +20499,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other832) { - metadata = other832.metadata; - isSupported = other832.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other842) { + metadata = other842.metadata; + isSupported = other842.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other833) { - metadata = other833.metadata; - isSupported = other833.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other843) { + metadata = other843.metadata; + isSupported = other843.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -20265,14 +20551,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size834; - ::apache::thrift::protocol::TType _etype837; - xfer += iprot->readListBegin(_etype837, _size834); - this->fileIds.resize(_size834); - uint32_t _i838; - for (_i838 = 0; _i838 < _size834; ++_i838) + uint32_t _size844; + ::apache::thrift::protocol::TType _etype847; + xfer += iprot->readListBegin(_etype847, _size844); + this->fileIds.resize(_size844); + uint32_t _i848; + for (_i848 = 0; _i848 < _size844; ++_i848) { - xfer += iprot->readI64(this->fileIds[_i838]); + xfer += iprot->readI64(this->fileIds[_i848]); } xfer += iprot->readListEnd(); } @@ -20303,10 +20589,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 _iter839; - for (_iter839 = this->fileIds.begin(); _iter839 != this->fileIds.end(); ++_iter839) + std::vector ::const_iterator _iter849; + for (_iter849 = this->fileIds.begin(); _iter849 != this->fileIds.end(); ++_iter849) { - xfer += oprot->writeI64((*_iter839)); + xfer += oprot->writeI64((*_iter849)); } xfer += oprot->writeListEnd(); } @@ -20322,11 +20608,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other840) { - fileIds = other840.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other850) { + fileIds = other850.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other841) { - fileIds = other841.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other851) { + fileIds = other851.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -20385,11 +20671,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other842) { - (void) other842; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other852) { + (void) other852; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other843) { - (void) other843; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other853) { + (void) other853; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -20443,14 +20729,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size844; - ::apache::thrift::protocol::TType _etype847; - xfer += iprot->readListBegin(_etype847, _size844); - this->fileIds.resize(_size844); - uint32_t _i848; - for (_i848 = 0; _i848 < _size844; ++_i848) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->fileIds.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += iprot->readI64(this->fileIds[_i848]); + xfer += iprot->readI64(this->fileIds[_i858]); } xfer += iprot->readListEnd(); } @@ -20463,14 +20749,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size849; - ::apache::thrift::protocol::TType _etype852; - xfer += iprot->readListBegin(_etype852, _size849); - this->metadata.resize(_size849); - uint32_t _i853; - for (_i853 = 0; _i853 < _size849; ++_i853) + uint32_t _size859; + ::apache::thrift::protocol::TType _etype862; + xfer += iprot->readListBegin(_etype862, _size859); + this->metadata.resize(_size859); + uint32_t _i863; + for (_i863 = 0; _i863 < _size859; ++_i863) { - xfer += iprot->readBinary(this->metadata[_i853]); + xfer += iprot->readBinary(this->metadata[_i863]); } xfer += iprot->readListEnd(); } @@ -20481,9 +20767,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast854; - xfer += iprot->readI32(ecast854); - this->type = (FileMetadataExprType::type)ecast854; + int32_t ecast864; + xfer += iprot->readI32(ecast864); + this->type = (FileMetadataExprType::type)ecast864; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -20513,10 +20799,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 _iter855; - for (_iter855 = this->fileIds.begin(); _iter855 != this->fileIds.end(); ++_iter855) + std::vector ::const_iterator _iter865; + for (_iter865 = this->fileIds.begin(); _iter865 != this->fileIds.end(); ++_iter865) { - xfer += oprot->writeI64((*_iter855)); + xfer += oprot->writeI64((*_iter865)); } xfer += oprot->writeListEnd(); } @@ -20525,10 +20811,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 _iter856; - for (_iter856 = this->metadata.begin(); _iter856 != this->metadata.end(); ++_iter856) + std::vector ::const_iterator _iter866; + for (_iter866 = this->metadata.begin(); _iter866 != this->metadata.end(); ++_iter866) { - xfer += oprot->writeBinary((*_iter856)); + xfer += oprot->writeBinary((*_iter866)); } xfer += oprot->writeListEnd(); } @@ -20552,17 +20838,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other857) { - fileIds = other857.fileIds; - metadata = other857.metadata; - type = other857.type; - __isset = other857.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other867) { + fileIds = other867.fileIds; + metadata = other867.metadata; + type = other867.type; + __isset = other867.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other858) { - fileIds = other858.fileIds; - metadata = other858.metadata; - type = other858.type; - __isset = other858.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other868) { + fileIds = other868.fileIds; + metadata = other868.metadata; + type = other868.type; + __isset = other868.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -20623,11 +20909,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other859) { - (void) other859; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other869) { + (void) other869; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other860) { - (void) other860; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other870) { + (void) other870; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -20671,14 +20957,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size861; - ::apache::thrift::protocol::TType _etype864; - xfer += iprot->readListBegin(_etype864, _size861); - this->fileIds.resize(_size861); - uint32_t _i865; - for (_i865 = 0; _i865 < _size861; ++_i865) + uint32_t _size871; + ::apache::thrift::protocol::TType _etype874; + xfer += iprot->readListBegin(_etype874, _size871); + this->fileIds.resize(_size871); + uint32_t _i875; + for (_i875 = 0; _i875 < _size871; ++_i875) { - xfer += iprot->readI64(this->fileIds[_i865]); + xfer += iprot->readI64(this->fileIds[_i875]); } xfer += iprot->readListEnd(); } @@ -20709,10 +20995,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 _iter866; - for (_iter866 = this->fileIds.begin(); _iter866 != this->fileIds.end(); ++_iter866) + std::vector ::const_iterator _iter876; + for (_iter876 = this->fileIds.begin(); _iter876 != this->fileIds.end(); ++_iter876) { - xfer += oprot->writeI64((*_iter866)); + xfer += oprot->writeI64((*_iter876)); } xfer += oprot->writeListEnd(); } @@ -20728,11 +21014,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other867) { - fileIds = other867.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other877) { + fileIds = other877.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other868) { - fileIds = other868.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other878) { + fileIds = other878.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -20814,11 +21100,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other869) { - isSupported = other869.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other879) { + isSupported = other879.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other870) { - isSupported = other870.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other880) { + isSupported = other880.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -20959,19 +21245,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other871) { - dbName = other871.dbName; - tblName = other871.tblName; - partName = other871.partName; - isAllParts = other871.isAllParts; - __isset = other871.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other881) { + dbName = other881.dbName; + tblName = other881.tblName; + partName = other881.partName; + isAllParts = other881.isAllParts; + __isset = other881.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other872) { - dbName = other872.dbName; - tblName = other872.tblName; - partName = other872.partName; - isAllParts = other872.isAllParts; - __isset = other872.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other882) { + dbName = other882.dbName; + tblName = other882.tblName; + partName = other882.partName; + isAllParts = other882.isAllParts; + __isset = other882.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -21019,14 +21305,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size873; - ::apache::thrift::protocol::TType _etype876; - xfer += iprot->readListBegin(_etype876, _size873); - this->functions.resize(_size873); - uint32_t _i877; - for (_i877 = 0; _i877 < _size873; ++_i877) + uint32_t _size883; + ::apache::thrift::protocol::TType _etype886; + xfer += iprot->readListBegin(_etype886, _size883); + this->functions.resize(_size883); + uint32_t _i887; + for (_i887 = 0; _i887 < _size883; ++_i887) { - xfer += this->functions[_i877].read(iprot); + xfer += this->functions[_i887].read(iprot); } xfer += iprot->readListEnd(); } @@ -21056,10 +21342,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 _iter878; - for (_iter878 = this->functions.begin(); _iter878 != this->functions.end(); ++_iter878) + std::vector ::const_iterator _iter888; + for (_iter888 = this->functions.begin(); _iter888 != this->functions.end(); ++_iter888) { - xfer += (*_iter878).write(oprot); + xfer += (*_iter888).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21076,13 +21362,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other879) { - functions = other879.functions; - __isset = other879.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other889) { + functions = other889.functions; + __isset = other889.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other880) { - functions = other880.functions; - __isset = other880.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other890) { + functions = other890.functions; + __isset = other890.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -21127,16 +21413,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size881; - ::apache::thrift::protocol::TType _etype884; - xfer += iprot->readListBegin(_etype884, _size881); - this->values.resize(_size881); - uint32_t _i885; - for (_i885 = 0; _i885 < _size881; ++_i885) + uint32_t _size891; + ::apache::thrift::protocol::TType _etype894; + xfer += iprot->readListBegin(_etype894, _size891); + this->values.resize(_size891); + uint32_t _i895; + for (_i895 = 0; _i895 < _size891; ++_i895) { - int32_t ecast886; - xfer += iprot->readI32(ecast886); - this->values[_i885] = (ClientCapability::type)ecast886; + int32_t ecast896; + xfer += iprot->readI32(ecast896); + this->values[_i895] = (ClientCapability::type)ecast896; } xfer += iprot->readListEnd(); } @@ -21167,10 +21453,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 _iter887; - for (_iter887 = this->values.begin(); _iter887 != this->values.end(); ++_iter887) + std::vector ::const_iterator _iter897; + for (_iter897 = this->values.begin(); _iter897 != this->values.end(); ++_iter897) { - xfer += oprot->writeI32((int32_t)(*_iter887)); + xfer += oprot->writeI32((int32_t)(*_iter897)); } xfer += oprot->writeListEnd(); } @@ -21186,11 +21472,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other888) { - values = other888.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other898) { + values = other898.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other889) { - values = other889.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other899) { + values = other899.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -21312,17 +21598,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other890) { - dbName = other890.dbName; - tblName = other890.tblName; - capabilities = other890.capabilities; - __isset = other890.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other900) { + dbName = other900.dbName; + tblName = other900.tblName; + capabilities = other900.capabilities; + __isset = other900.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other891) { - dbName = other891.dbName; - tblName = other891.tblName; - capabilities = other891.capabilities; - __isset = other891.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other901) { + dbName = other901.dbName; + tblName = other901.tblName; + capabilities = other901.capabilities; + __isset = other901.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -21406,11 +21692,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other892) { - table = other892.table; +GetTableResult::GetTableResult(const GetTableResult& other902) { + table = other902.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other893) { - table = other893.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other903) { + table = other903.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -21473,14 +21759,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - this->tblNames.resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + this->tblNames.resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += iprot->readString(this->tblNames[_i898]); + xfer += iprot->readString(this->tblNames[_i908]); } xfer += iprot->readListEnd(); } @@ -21524,10 +21810,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 _iter899; - for (_iter899 = this->tblNames.begin(); _iter899 != this->tblNames.end(); ++_iter899) + std::vector ::const_iterator _iter909; + for (_iter909 = this->tblNames.begin(); _iter909 != this->tblNames.end(); ++_iter909) { - xfer += oprot->writeString((*_iter899)); + xfer += oprot->writeString((*_iter909)); } xfer += oprot->writeListEnd(); } @@ -21551,17 +21837,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other900) { - dbName = other900.dbName; - tblNames = other900.tblNames; - capabilities = other900.capabilities; - __isset = other900.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other910) { + dbName = other910.dbName; + tblNames = other910.tblNames; + capabilities = other910.capabilities; + __isset = other910.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other901) { - dbName = other901.dbName; - tblNames = other901.tblNames; - capabilities = other901.capabilities; - __isset = other901.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other911) { + dbName = other911.dbName; + tblNames = other911.tblNames; + capabilities = other911.capabilities; + __isset = other911.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -21608,14 +21894,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size902; - ::apache::thrift::protocol::TType _etype905; - xfer += iprot->readListBegin(_etype905, _size902); - this->tables.resize(_size902); - uint32_t _i906; - for (_i906 = 0; _i906 < _size902; ++_i906) + uint32_t _size912; + ::apache::thrift::protocol::TType _etype915; + xfer += iprot->readListBegin(_etype915, _size912); + this->tables.resize(_size912); + uint32_t _i916; + for (_i916 = 0; _i916 < _size912; ++_i916) { - xfer += this->tables[_i906].read(iprot); + xfer += this->tables[_i916].read(iprot); } xfer += iprot->readListEnd(); } @@ -21646,10 +21932,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 _iter907; - for (_iter907 = this->tables.begin(); _iter907 != this->tables.end(); ++_iter907) + std::vector
::const_iterator _iter917; + for (_iter917 = this->tables.begin(); _iter917 != this->tables.end(); ++_iter917) { - xfer += (*_iter907).write(oprot); + xfer += (*_iter917).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21665,11 +21951,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other908) { - tables = other908.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other918) { + tables = other918.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other909) { - tables = other909.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other919) { + tables = other919.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -21771,13 +22057,13 @@ void swap(CmRecycleRequest &a, CmRecycleRequest &b) { swap(a.purge, b.purge); } -CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other910) { - dataPath = other910.dataPath; - purge = other910.purge; +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other920) { + dataPath = other920.dataPath; + purge = other920.purge; } -CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other911) { - dataPath = other911.dataPath; - purge = other911.purge; +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other921) { + dataPath = other921.dataPath; + purge = other921.purge; return *this; } void CmRecycleRequest::printTo(std::ostream& out) const { @@ -21837,11 +22123,11 @@ void swap(CmRecycleResponse &a, CmRecycleResponse &b) { (void) b; } -CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other912) { - (void) other912; +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other922) { + (void) other922; } -CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other913) { - (void) other913; +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other923) { + (void) other923; return *this; } void CmRecycleResponse::printTo(std::ostream& out) const { @@ -21982,19 +22268,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other914) { - dbName = other914.dbName; - tableName = other914.tableName; - tableType = other914.tableType; - comments = other914.comments; - __isset = other914.__isset; +TableMeta::TableMeta(const TableMeta& other924) { + dbName = other924.dbName; + tableName = other924.tableName; + tableType = other924.tableType; + comments = other924.comments; + __isset = other924.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other915) { - dbName = other915.dbName; - tableName = other915.tableName; - tableType = other915.tableType; - comments = other915.comments; - __isset = other915.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other925) { + dbName = other925.dbName; + tableName = other925.tableName; + tableType = other925.tableType; + comments = other925.comments; + __isset = other925.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -22052,15 +22338,15 @@ uint32_t Materialization::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size916; - ::apache::thrift::protocol::TType _etype919; - xfer += iprot->readSetBegin(_etype919, _size916); - uint32_t _i920; - for (_i920 = 0; _i920 < _size916; ++_i920) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readSetBegin(_etype929, _size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - std::string _elem921; - xfer += iprot->readString(_elem921); - this->tablesUsed.insert(_elem921); + std::string _elem931; + xfer += iprot->readString(_elem931); + this->tablesUsed.insert(_elem931); } xfer += iprot->readSetEnd(); } @@ -22109,10 +22395,10 @@ uint32_t Materialization::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); - std::set ::const_iterator _iter922; - for (_iter922 = this->tablesUsed.begin(); _iter922 != this->tablesUsed.end(); ++_iter922) + std::set ::const_iterator _iter932; + for (_iter932 = this->tablesUsed.begin(); _iter932 != this->tablesUsed.end(); ++_iter932) { - xfer += oprot->writeString((*_iter922)); + xfer += oprot->writeString((*_iter932)); } xfer += oprot->writeSetEnd(); } @@ -22140,17 +22426,17 @@ void swap(Materialization &a, Materialization &b) { swap(a.__isset, b.__isset); } -Materialization::Materialization(const Materialization& other923) { - tablesUsed = other923.tablesUsed; - validTxnList = other923.validTxnList; - invalidationTime = other923.invalidationTime; - __isset = other923.__isset; +Materialization::Materialization(const Materialization& other933) { + tablesUsed = other933.tablesUsed; + validTxnList = other933.validTxnList; + invalidationTime = other933.invalidationTime; + __isset = other933.__isset; } -Materialization& Materialization::operator=(const Materialization& other924) { - tablesUsed = other924.tablesUsed; - validTxnList = other924.validTxnList; - invalidationTime = other924.invalidationTime; - __isset = other924.__isset; +Materialization& Materialization::operator=(const Materialization& other934) { + tablesUsed = other934.tablesUsed; + validTxnList = other934.validTxnList; + invalidationTime = other934.invalidationTime; + __isset = other934.__isset; return *this; } void Materialization::printTo(std::ostream& out) const { @@ -22218,9 +22504,9 @@ uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast925; - xfer += iprot->readI32(ecast925); - this->status = (WMResourcePlanStatus::type)ecast925; + int32_t ecast935; + xfer += iprot->readI32(ecast935); + this->status = (WMResourcePlanStatus::type)ecast935; this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -22294,19 +22580,19 @@ void swap(WMResourcePlan &a, WMResourcePlan &b) { swap(a.__isset, b.__isset); } -WMResourcePlan::WMResourcePlan(const WMResourcePlan& other926) { - name = other926.name; - status = other926.status; - queryParallelism = other926.queryParallelism; - defaultPoolPath = other926.defaultPoolPath; - __isset = other926.__isset; +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other936) { + name = other936.name; + status = other936.status; + queryParallelism = other936.queryParallelism; + defaultPoolPath = other936.defaultPoolPath; + __isset = other936.__isset; } -WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other927) { - name = other927.name; - status = other927.status; - queryParallelism = other927.queryParallelism; - defaultPoolPath = other927.defaultPoolPath; - __isset = other927.__isset; +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other937) { + name = other937.name; + status = other937.status; + queryParallelism = other937.queryParallelism; + defaultPoolPath = other937.defaultPoolPath; + __isset = other937.__isset; return *this; } void WMResourcePlan::printTo(std::ostream& out) const { @@ -22385,9 +22671,9 @@ uint32_t WMNullableResourcePlan::read(::apache::thrift::protocol::TProtocol* ipr break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast928; - xfer += iprot->readI32(ecast928); - this->status = (WMResourcePlanStatus::type)ecast928; + int32_t ecast938; + xfer += iprot->readI32(ecast938); + this->status = (WMResourcePlanStatus::type)ecast938; this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -22489,23 +22775,23 @@ void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) { swap(a.__isset, b.__isset); } -WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other929) { - name = other929.name; - status = other929.status; - queryParallelism = other929.queryParallelism; - isSetQueryParallelism = other929.isSetQueryParallelism; - defaultPoolPath = other929.defaultPoolPath; - isSetDefaultPoolPath = other929.isSetDefaultPoolPath; - __isset = other929.__isset; -} -WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other930) { - name = other930.name; - status = other930.status; - queryParallelism = other930.queryParallelism; - isSetQueryParallelism = other930.isSetQueryParallelism; - defaultPoolPath = other930.defaultPoolPath; - isSetDefaultPoolPath = other930.isSetDefaultPoolPath; - __isset = other930.__isset; +WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other939) { + name = other939.name; + status = other939.status; + queryParallelism = other939.queryParallelism; + isSetQueryParallelism = other939.isSetQueryParallelism; + defaultPoolPath = other939.defaultPoolPath; + isSetDefaultPoolPath = other939.isSetDefaultPoolPath; + __isset = other939.__isset; +} +WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other940) { + name = other940.name; + status = other940.status; + queryParallelism = other940.queryParallelism; + isSetQueryParallelism = other940.isSetQueryParallelism; + defaultPoolPath = other940.defaultPoolPath; + isSetDefaultPoolPath = other940.isSetDefaultPoolPath; + __isset = other940.__isset; return *this; } void WMNullableResourcePlan::printTo(std::ostream& out) const { @@ -22670,21 +22956,21 @@ void swap(WMPool &a, WMPool &b) { swap(a.__isset, b.__isset); } -WMPool::WMPool(const WMPool& other931) { - resourcePlanName = other931.resourcePlanName; - poolPath = other931.poolPath; - allocFraction = other931.allocFraction; - queryParallelism = other931.queryParallelism; - schedulingPolicy = other931.schedulingPolicy; - __isset = other931.__isset; -} -WMPool& WMPool::operator=(const WMPool& other932) { - resourcePlanName = other932.resourcePlanName; - poolPath = other932.poolPath; - allocFraction = other932.allocFraction; - queryParallelism = other932.queryParallelism; - schedulingPolicy = other932.schedulingPolicy; - __isset = other932.__isset; +WMPool::WMPool(const WMPool& other941) { + resourcePlanName = other941.resourcePlanName; + poolPath = other941.poolPath; + allocFraction = other941.allocFraction; + queryParallelism = other941.queryParallelism; + schedulingPolicy = other941.schedulingPolicy; + __isset = other941.__isset; +} +WMPool& WMPool::operator=(const WMPool& other942) { + resourcePlanName = other942.resourcePlanName; + poolPath = other942.poolPath; + allocFraction = other942.allocFraction; + queryParallelism = other942.queryParallelism; + schedulingPolicy = other942.schedulingPolicy; + __isset = other942.__isset; return *this; } void WMPool::printTo(std::ostream& out) const { @@ -22867,23 +23153,23 @@ void swap(WMNullablePool &a, WMNullablePool &b) { swap(a.__isset, b.__isset); } -WMNullablePool::WMNullablePool(const WMNullablePool& other933) { - resourcePlanName = other933.resourcePlanName; - poolPath = other933.poolPath; - allocFraction = other933.allocFraction; - queryParallelism = other933.queryParallelism; - schedulingPolicy = other933.schedulingPolicy; - isSetSchedulingPolicy = other933.isSetSchedulingPolicy; - __isset = other933.__isset; -} -WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other934) { - resourcePlanName = other934.resourcePlanName; - poolPath = other934.poolPath; - allocFraction = other934.allocFraction; - queryParallelism = other934.queryParallelism; - schedulingPolicy = other934.schedulingPolicy; - isSetSchedulingPolicy = other934.isSetSchedulingPolicy; - __isset = other934.__isset; +WMNullablePool::WMNullablePool(const WMNullablePool& other943) { + resourcePlanName = other943.resourcePlanName; + poolPath = other943.poolPath; + allocFraction = other943.allocFraction; + queryParallelism = other943.queryParallelism; + schedulingPolicy = other943.schedulingPolicy; + isSetSchedulingPolicy = other943.isSetSchedulingPolicy; + __isset = other943.__isset; +} +WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other944) { + resourcePlanName = other944.resourcePlanName; + poolPath = other944.poolPath; + allocFraction = other944.allocFraction; + queryParallelism = other944.queryParallelism; + schedulingPolicy = other944.schedulingPolicy; + isSetSchedulingPolicy = other944.isSetSchedulingPolicy; + __isset = other944.__isset; return *this; } void WMNullablePool::printTo(std::ostream& out) const { @@ -23048,21 +23334,21 @@ void swap(WMTrigger &a, WMTrigger &b) { swap(a.__isset, b.__isset); } -WMTrigger::WMTrigger(const WMTrigger& other935) { - resourcePlanName = other935.resourcePlanName; - triggerName = other935.triggerName; - triggerExpression = other935.triggerExpression; - actionExpression = other935.actionExpression; - isInUnmanaged = other935.isInUnmanaged; - __isset = other935.__isset; -} -WMTrigger& WMTrigger::operator=(const WMTrigger& other936) { - resourcePlanName = other936.resourcePlanName; - triggerName = other936.triggerName; - triggerExpression = other936.triggerExpression; - actionExpression = other936.actionExpression; - isInUnmanaged = other936.isInUnmanaged; - __isset = other936.__isset; +WMTrigger::WMTrigger(const WMTrigger& other945) { + resourcePlanName = other945.resourcePlanName; + triggerName = other945.triggerName; + triggerExpression = other945.triggerExpression; + actionExpression = other945.actionExpression; + isInUnmanaged = other945.isInUnmanaged; + __isset = other945.__isset; +} +WMTrigger& WMTrigger::operator=(const WMTrigger& other946) { + resourcePlanName = other946.resourcePlanName; + triggerName = other946.triggerName; + triggerExpression = other946.triggerExpression; + actionExpression = other946.actionExpression; + isInUnmanaged = other946.isInUnmanaged; + __isset = other946.__isset; return *this; } void WMTrigger::printTo(std::ostream& out) const { @@ -23227,21 +23513,21 @@ void swap(WMMapping &a, WMMapping &b) { swap(a.__isset, b.__isset); } -WMMapping::WMMapping(const WMMapping& other937) { - resourcePlanName = other937.resourcePlanName; - entityType = other937.entityType; - entityName = other937.entityName; - poolPath = other937.poolPath; - ordering = other937.ordering; - __isset = other937.__isset; -} -WMMapping& WMMapping::operator=(const WMMapping& other938) { - resourcePlanName = other938.resourcePlanName; - entityType = other938.entityType; - entityName = other938.entityName; - poolPath = other938.poolPath; - ordering = other938.ordering; - __isset = other938.__isset; +WMMapping::WMMapping(const WMMapping& other947) { + resourcePlanName = other947.resourcePlanName; + entityType = other947.entityType; + entityName = other947.entityName; + poolPath = other947.poolPath; + ordering = other947.ordering; + __isset = other947.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other948) { + resourcePlanName = other948.resourcePlanName; + entityType = other948.entityType; + entityName = other948.entityName; + poolPath = other948.poolPath; + ordering = other948.ordering; + __isset = other948.__isset; return *this; } void WMMapping::printTo(std::ostream& out) const { @@ -23347,13 +23633,13 @@ void swap(WMPoolTrigger &a, WMPoolTrigger &b) { swap(a.trigger, b.trigger); } -WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other939) { - pool = other939.pool; - trigger = other939.trigger; +WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other949) { + pool = other949.pool; + trigger = other949.trigger; } -WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other940) { - pool = other940.pool; - trigger = other940.trigger; +WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other950) { + pool = other950.pool; + trigger = other950.trigger; return *this; } void WMPoolTrigger::printTo(std::ostream& out) const { @@ -23427,14 +23713,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->pools.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->pools.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size951; + ::apache::thrift::protocol::TType _etype954; + xfer += iprot->readListBegin(_etype954, _size951); + this->pools.resize(_size951); + uint32_t _i955; + for (_i955 = 0; _i955 < _size951; ++_i955) { - xfer += this->pools[_i945].read(iprot); + xfer += this->pools[_i955].read(iprot); } xfer += iprot->readListEnd(); } @@ -23447,14 +23733,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->mappings.clear(); - uint32_t _size946; - ::apache::thrift::protocol::TType _etype949; - xfer += iprot->readListBegin(_etype949, _size946); - this->mappings.resize(_size946); - uint32_t _i950; - for (_i950 = 0; _i950 < _size946; ++_i950) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->mappings.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += this->mappings[_i950].read(iprot); + xfer += this->mappings[_i960].read(iprot); } xfer += iprot->readListEnd(); } @@ -23467,14 +23753,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size951; - ::apache::thrift::protocol::TType _etype954; - xfer += iprot->readListBegin(_etype954, _size951); - this->triggers.resize(_size951); - uint32_t _i955; - for (_i955 = 0; _i955 < _size951; ++_i955) + uint32_t _size961; + ::apache::thrift::protocol::TType _etype964; + xfer += iprot->readListBegin(_etype964, _size961); + this->triggers.resize(_size961); + uint32_t _i965; + for (_i965 = 0; _i965 < _size961; ++_i965) { - xfer += this->triggers[_i955].read(iprot); + xfer += this->triggers[_i965].read(iprot); } xfer += iprot->readListEnd(); } @@ -23487,14 +23773,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->poolTriggers.clear(); - uint32_t _size956; - ::apache::thrift::protocol::TType _etype959; - xfer += iprot->readListBegin(_etype959, _size956); - this->poolTriggers.resize(_size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->poolTriggers.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += this->poolTriggers[_i960].read(iprot); + xfer += this->poolTriggers[_i970].read(iprot); } xfer += iprot->readListEnd(); } @@ -23531,10 +23817,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("pools", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->pools.size())); - std::vector ::const_iterator _iter961; - for (_iter961 = this->pools.begin(); _iter961 != this->pools.end(); ++_iter961) + std::vector ::const_iterator _iter971; + for (_iter971 = this->pools.begin(); _iter971 != this->pools.end(); ++_iter971) { - xfer += (*_iter961).write(oprot); + xfer += (*_iter971).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23544,10 +23830,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("mappings", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->mappings.size())); - std::vector ::const_iterator _iter962; - for (_iter962 = this->mappings.begin(); _iter962 != this->mappings.end(); ++_iter962) + std::vector ::const_iterator _iter972; + for (_iter972 = this->mappings.begin(); _iter972 != this->mappings.end(); ++_iter972) { - xfer += (*_iter962).write(oprot); + xfer += (*_iter972).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23557,10 +23843,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter963; - for (_iter963 = this->triggers.begin(); _iter963 != this->triggers.end(); ++_iter963) + std::vector ::const_iterator _iter973; + for (_iter973 = this->triggers.begin(); _iter973 != this->triggers.end(); ++_iter973) { - xfer += (*_iter963).write(oprot); + xfer += (*_iter973).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23570,10 +23856,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("poolTriggers", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->poolTriggers.size())); - std::vector ::const_iterator _iter964; - for (_iter964 = this->poolTriggers.begin(); _iter964 != this->poolTriggers.end(); ++_iter964) + std::vector ::const_iterator _iter974; + for (_iter974 = this->poolTriggers.begin(); _iter974 != this->poolTriggers.end(); ++_iter974) { - xfer += (*_iter964).write(oprot); + xfer += (*_iter974).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23594,21 +23880,21 @@ void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) { swap(a.__isset, b.__isset); } -WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other965) { - plan = other965.plan; - pools = other965.pools; - mappings = other965.mappings; - triggers = other965.triggers; - poolTriggers = other965.poolTriggers; - __isset = other965.__isset; -} -WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other966) { - plan = other966.plan; - pools = other966.pools; - mappings = other966.mappings; - triggers = other966.triggers; - poolTriggers = other966.poolTriggers; - __isset = other966.__isset; +WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other975) { + plan = other975.plan; + pools = other975.pools; + mappings = other975.mappings; + triggers = other975.triggers; + poolTriggers = other975.poolTriggers; + __isset = other975.__isset; +} +WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other976) { + plan = other976.plan; + pools = other976.pools; + mappings = other976.mappings; + triggers = other976.triggers; + poolTriggers = other976.poolTriggers; + __isset = other976.__isset; return *this; } void WMFullResourcePlan::printTo(std::ostream& out) const { @@ -23713,15 +23999,15 @@ void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other967) { - resourcePlan = other967.resourcePlan; - copyFrom = other967.copyFrom; - __isset = other967.__isset; +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other977) { + resourcePlan = other977.resourcePlan; + copyFrom = other977.copyFrom; + __isset = other977.__isset; } -WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other968) { - resourcePlan = other968.resourcePlan; - copyFrom = other968.copyFrom; - __isset = other968.__isset; +WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other978) { + resourcePlan = other978.resourcePlan; + copyFrom = other978.copyFrom; + __isset = other978.__isset; return *this; } void WMCreateResourcePlanRequest::printTo(std::ostream& out) const { @@ -23781,11 +24067,11 @@ void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) { (void) b; } -WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other969) { - (void) other969; +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other979) { + (void) other979; } -WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other970) { - (void) other970; +WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other980) { + (void) other980; return *this; } void WMCreateResourcePlanResponse::printTo(std::ostream& out) const { @@ -23843,11 +24129,11 @@ void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) (void) b; } -WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other971) { - (void) other971; +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other981) { + (void) other981; } -WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other972) { - (void) other972; +WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other982) { + (void) other982; return *this; } void WMGetActiveResourcePlanRequest::printTo(std::ostream& out) const { @@ -23928,13 +24214,13 @@ void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other973) { - resourcePlan = other973.resourcePlan; - __isset = other973.__isset; +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other983) { + resourcePlan = other983.resourcePlan; + __isset = other983.__isset; } -WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other974) { - resourcePlan = other974.resourcePlan; - __isset = other974.__isset; +WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other984) { + resourcePlan = other984.resourcePlan; + __isset = other984.__isset; return *this; } void WMGetActiveResourcePlanResponse::printTo(std::ostream& out) const { @@ -24016,13 +24302,13 @@ void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other975) { - resourcePlanName = other975.resourcePlanName; - __isset = other975.__isset; +WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other985) { + resourcePlanName = other985.resourcePlanName; + __isset = other985.__isset; } -WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other976) { - resourcePlanName = other976.resourcePlanName; - __isset = other976.__isset; +WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other986) { + resourcePlanName = other986.resourcePlanName; + __isset = other986.__isset; return *this; } void WMGetResourcePlanRequest::printTo(std::ostream& out) const { @@ -24104,13 +24390,13 @@ void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other977) { - resourcePlan = other977.resourcePlan; - __isset = other977.__isset; +WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other987) { + resourcePlan = other987.resourcePlan; + __isset = other987.__isset; } -WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other978) { - resourcePlan = other978.resourcePlan; - __isset = other978.__isset; +WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other988) { + resourcePlan = other988.resourcePlan; + __isset = other988.__isset; return *this; } void WMGetResourcePlanResponse::printTo(std::ostream& out) const { @@ -24169,11 +24455,11 @@ void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) { (void) b; } -WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other979) { - (void) other979; +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other989) { + (void) other989; } -WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other980) { - (void) other980; +WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other990) { + (void) other990; return *this; } void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const { @@ -24217,14 +24503,14 @@ uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourcePlans.clear(); - uint32_t _size981; - ::apache::thrift::protocol::TType _etype984; - xfer += iprot->readListBegin(_etype984, _size981); - this->resourcePlans.resize(_size981); - uint32_t _i985; - for (_i985 = 0; _i985 < _size981; ++_i985) + uint32_t _size991; + ::apache::thrift::protocol::TType _etype994; + xfer += iprot->readListBegin(_etype994, _size991); + this->resourcePlans.resize(_size991); + uint32_t _i995; + for (_i995 = 0; _i995 < _size991; ++_i995) { - xfer += this->resourcePlans[_i985].read(iprot); + xfer += this->resourcePlans[_i995].read(iprot); } xfer += iprot->readListEnd(); } @@ -24254,10 +24540,10 @@ uint32_t WMGetAllResourcePlanResponse::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("resourcePlans", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourcePlans.size())); - std::vector ::const_iterator _iter986; - for (_iter986 = this->resourcePlans.begin(); _iter986 != this->resourcePlans.end(); ++_iter986) + std::vector ::const_iterator _iter996; + for (_iter996 = this->resourcePlans.begin(); _iter996 != this->resourcePlans.end(); ++_iter996) { - xfer += (*_iter986).write(oprot); + xfer += (*_iter996).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24274,13 +24560,13 @@ void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other987) { - resourcePlans = other987.resourcePlans; - __isset = other987.__isset; +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other997) { + resourcePlans = other997.resourcePlans; + __isset = other997.__isset; } -WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other988) { - resourcePlans = other988.resourcePlans; - __isset = other988.__isset; +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other998) { + resourcePlans = other998.resourcePlans; + __isset = other998.__isset; return *this; } void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { @@ -24438,21 +24724,21 @@ void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other989) { - resourcePlanName = other989.resourcePlanName; - resourcePlan = other989.resourcePlan; - isEnableAndActivate = other989.isEnableAndActivate; - isForceDeactivate = other989.isForceDeactivate; - isReplace = other989.isReplace; - __isset = other989.__isset; -} -WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other990) { - resourcePlanName = other990.resourcePlanName; - resourcePlan = other990.resourcePlan; - isEnableAndActivate = other990.isEnableAndActivate; - isForceDeactivate = other990.isForceDeactivate; - isReplace = other990.isReplace; - __isset = other990.__isset; +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other999) { + resourcePlanName = other999.resourcePlanName; + resourcePlan = other999.resourcePlan; + isEnableAndActivate = other999.isEnableAndActivate; + isForceDeactivate = other999.isForceDeactivate; + isReplace = other999.isReplace; + __isset = other999.__isset; +} +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1000) { + resourcePlanName = other1000.resourcePlanName; + resourcePlan = other1000.resourcePlan; + isEnableAndActivate = other1000.isEnableAndActivate; + isForceDeactivate = other1000.isForceDeactivate; + isReplace = other1000.isReplace; + __isset = other1000.__isset; return *this; } void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { @@ -24538,13 +24824,13 @@ void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other991) { - fullResourcePlan = other991.fullResourcePlan; - __isset = other991.__isset; +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1001) { + fullResourcePlan = other1001.fullResourcePlan; + __isset = other1001.__isset; } -WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other992) { - fullResourcePlan = other992.fullResourcePlan; - __isset = other992.__isset; +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1002) { + fullResourcePlan = other1002.fullResourcePlan; + __isset = other1002.__isset; return *this; } void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { @@ -24626,13 +24912,13 @@ void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other993) { - resourcePlanName = other993.resourcePlanName; - __isset = other993.__isset; +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1003) { + resourcePlanName = other1003.resourcePlanName; + __isset = other1003.__isset; } -WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other994) { - resourcePlanName = other994.resourcePlanName; - __isset = other994.__isset; +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1004) { + resourcePlanName = other1004.resourcePlanName; + __isset = other1004.__isset; return *this; } void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { @@ -24682,14 +24968,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->errors.clear(); - uint32_t _size995; - ::apache::thrift::protocol::TType _etype998; - xfer += iprot->readListBegin(_etype998, _size995); - this->errors.resize(_size995); - uint32_t _i999; - for (_i999 = 0; _i999 < _size995; ++_i999) + uint32_t _size1005; + ::apache::thrift::protocol::TType _etype1008; + xfer += iprot->readListBegin(_etype1008, _size1005); + this->errors.resize(_size1005); + uint32_t _i1009; + for (_i1009 = 0; _i1009 < _size1005; ++_i1009) { - xfer += iprot->readString(this->errors[_i999]); + xfer += iprot->readString(this->errors[_i1009]); } xfer += iprot->readListEnd(); } @@ -24702,14 +24988,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->warnings.clear(); - uint32_t _size1000; - ::apache::thrift::protocol::TType _etype1003; - xfer += iprot->readListBegin(_etype1003, _size1000); - this->warnings.resize(_size1000); - uint32_t _i1004; - for (_i1004 = 0; _i1004 < _size1000; ++_i1004) + uint32_t _size1010; + ::apache::thrift::protocol::TType _etype1013; + xfer += iprot->readListBegin(_etype1013, _size1010); + this->warnings.resize(_size1010); + uint32_t _i1014; + for (_i1014 = 0; _i1014 < _size1010; ++_i1014) { - xfer += iprot->readString(this->warnings[_i1004]); + xfer += iprot->readString(this->warnings[_i1014]); } xfer += iprot->readListEnd(); } @@ -24739,10 +25025,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->errors.size())); - std::vector ::const_iterator _iter1005; - for (_iter1005 = this->errors.begin(); _iter1005 != this->errors.end(); ++_iter1005) + std::vector ::const_iterator _iter1015; + for (_iter1015 = this->errors.begin(); _iter1015 != this->errors.end(); ++_iter1015) { - xfer += oprot->writeString((*_iter1005)); + xfer += oprot->writeString((*_iter1015)); } xfer += oprot->writeListEnd(); } @@ -24752,10 +25038,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("warnings", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->warnings.size())); - std::vector ::const_iterator _iter1006; - for (_iter1006 = this->warnings.begin(); _iter1006 != this->warnings.end(); ++_iter1006) + std::vector ::const_iterator _iter1016; + for (_iter1016 = this->warnings.begin(); _iter1016 != this->warnings.end(); ++_iter1016) { - xfer += oprot->writeString((*_iter1006)); + xfer += oprot->writeString((*_iter1016)); } xfer += oprot->writeListEnd(); } @@ -24773,15 +25059,15 @@ void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) swap(a.__isset, b.__isset); } -WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1007) { - errors = other1007.errors; - warnings = other1007.warnings; - __isset = other1007.__isset; +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1017) { + errors = other1017.errors; + warnings = other1017.warnings; + __isset = other1017.__isset; } -WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1008) { - errors = other1008.errors; - warnings = other1008.warnings; - __isset = other1008.__isset; +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1018) { + errors = other1018.errors; + warnings = other1018.warnings; + __isset = other1018.__isset; return *this; } void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { @@ -24864,13 +25150,13 @@ void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1009) { - resourcePlanName = other1009.resourcePlanName; - __isset = other1009.__isset; +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1019) { + resourcePlanName = other1019.resourcePlanName; + __isset = other1019.__isset; } -WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1010) { - resourcePlanName = other1010.resourcePlanName; - __isset = other1010.__isset; +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1020) { + resourcePlanName = other1020.resourcePlanName; + __isset = other1020.__isset; return *this; } void WMDropResourcePlanRequest::printTo(std::ostream& out) const { @@ -24929,11 +25215,11 @@ void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { (void) b; } -WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1011) { - (void) other1011; +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1021) { + (void) other1021; } -WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1012) { - (void) other1012; +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1022) { + (void) other1022; return *this; } void WMDropResourcePlanResponse::printTo(std::ostream& out) const { @@ -25014,13 +25300,13 @@ void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1013) { - trigger = other1013.trigger; - __isset = other1013.__isset; +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1023) { + trigger = other1023.trigger; + __isset = other1023.__isset; } -WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1014) { - trigger = other1014.trigger; - __isset = other1014.__isset; +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1024) { + trigger = other1024.trigger; + __isset = other1024.__isset; return *this; } void WMCreateTriggerRequest::printTo(std::ostream& out) const { @@ -25079,11 +25365,11 @@ void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) { (void) b; } -WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1015) { - (void) other1015; +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1025) { + (void) other1025; } -WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1016) { - (void) other1016; +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1026) { + (void) other1026; return *this; } void WMCreateTriggerResponse::printTo(std::ostream& out) const { @@ -25164,13 +25450,13 @@ void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1017) { - trigger = other1017.trigger; - __isset = other1017.__isset; +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1027) { + trigger = other1027.trigger; + __isset = other1027.__isset; } -WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1018) { - trigger = other1018.trigger; - __isset = other1018.__isset; +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1028) { + trigger = other1028.trigger; + __isset = other1028.__isset; return *this; } void WMAlterTriggerRequest::printTo(std::ostream& out) const { @@ -25229,11 +25515,11 @@ void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) { (void) b; } -WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1019) { - (void) other1019; +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1029) { + (void) other1029; } -WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1020) { - (void) other1020; +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1030) { + (void) other1030; return *this; } void WMAlterTriggerResponse::printTo(std::ostream& out) const { @@ -25333,15 +25619,15 @@ void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1021) { - resourcePlanName = other1021.resourcePlanName; - triggerName = other1021.triggerName; - __isset = other1021.__isset; +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1031) { + resourcePlanName = other1031.resourcePlanName; + triggerName = other1031.triggerName; + __isset = other1031.__isset; } -WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1022) { - resourcePlanName = other1022.resourcePlanName; - triggerName = other1022.triggerName; - __isset = other1022.__isset; +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1032) { + resourcePlanName = other1032.resourcePlanName; + triggerName = other1032.triggerName; + __isset = other1032.__isset; return *this; } void WMDropTriggerRequest::printTo(std::ostream& out) const { @@ -25401,11 +25687,11 @@ void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) { (void) b; } -WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1023) { - (void) other1023; +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1033) { + (void) other1033; } -WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1024) { - (void) other1024; +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1034) { + (void) other1034; return *this; } void WMDropTriggerResponse::printTo(std::ostream& out) const { @@ -25486,13 +25772,13 @@ void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequ swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1025) { - resourcePlanName = other1025.resourcePlanName; - __isset = other1025.__isset; +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1035) { + resourcePlanName = other1035.resourcePlanName; + __isset = other1035.__isset; } -WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1026) { - resourcePlanName = other1026.resourcePlanName; - __isset = other1026.__isset; +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1036) { + resourcePlanName = other1036.resourcePlanName; + __isset = other1036.__isset; return *this; } void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { @@ -25537,14 +25823,14 @@ uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1027; - ::apache::thrift::protocol::TType _etype1030; - xfer += iprot->readListBegin(_etype1030, _size1027); - this->triggers.resize(_size1027); - uint32_t _i1031; - for (_i1031 = 0; _i1031 < _size1027; ++_i1031) + uint32_t _size1037; + ::apache::thrift::protocol::TType _etype1040; + xfer += iprot->readListBegin(_etype1040, _size1037); + this->triggers.resize(_size1037); + uint32_t _i1041; + for (_i1041 = 0; _i1041 < _size1037; ++_i1041) { - xfer += this->triggers[_i1031].read(iprot); + xfer += this->triggers[_i1041].read(iprot); } xfer += iprot->readListEnd(); } @@ -25574,10 +25860,10 @@ uint32_t WMGetTriggersForResourePlanResponse::write(::apache::thrift::protocol:: xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter1032; - for (_iter1032 = this->triggers.begin(); _iter1032 != this->triggers.end(); ++_iter1032) + std::vector ::const_iterator _iter1042; + for (_iter1042 = this->triggers.begin(); _iter1042 != this->triggers.end(); ++_iter1042) { - xfer += (*_iter1032).write(oprot); + xfer += (*_iter1042).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25594,13 +25880,13 @@ void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanRes swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1033) { - triggers = other1033.triggers; - __isset = other1033.__isset; +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1043) { + triggers = other1043.triggers; + __isset = other1043.__isset; } -WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1034) { - triggers = other1034.triggers; - __isset = other1034.__isset; +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1044) { + triggers = other1044.triggers; + __isset = other1044.__isset; return *this; } void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { @@ -25682,13 +25968,13 @@ void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) { swap(a.__isset, b.__isset); } -WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1035) { - pool = other1035.pool; - __isset = other1035.__isset; +WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1045) { + pool = other1045.pool; + __isset = other1045.__isset; } -WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1036) { - pool = other1036.pool; - __isset = other1036.__isset; +WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1046) { + pool = other1046.pool; + __isset = other1046.__isset; return *this; } void WMCreatePoolRequest::printTo(std::ostream& out) const { @@ -25747,11 +26033,11 @@ void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) { (void) b; } -WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1037) { - (void) other1037; +WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1047) { + (void) other1047; } -WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1038) { - (void) other1038; +WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1048) { + (void) other1048; return *this; } void WMCreatePoolResponse::printTo(std::ostream& out) const { @@ -25851,15 +26137,15 @@ void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) { swap(a.__isset, b.__isset); } -WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1039) { - pool = other1039.pool; - poolPath = other1039.poolPath; - __isset = other1039.__isset; +WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1049) { + pool = other1049.pool; + poolPath = other1049.poolPath; + __isset = other1049.__isset; } -WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1040) { - pool = other1040.pool; - poolPath = other1040.poolPath; - __isset = other1040.__isset; +WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1050) { + pool = other1050.pool; + poolPath = other1050.poolPath; + __isset = other1050.__isset; return *this; } void WMAlterPoolRequest::printTo(std::ostream& out) const { @@ -25919,11 +26205,11 @@ void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) { (void) b; } -WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1041) { - (void) other1041; +WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1051) { + (void) other1051; } -WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1042) { - (void) other1042; +WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1052) { + (void) other1052; return *this; } void WMAlterPoolResponse::printTo(std::ostream& out) const { @@ -26023,15 +26309,15 @@ void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) { swap(a.__isset, b.__isset); } -WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1043) { - resourcePlanName = other1043.resourcePlanName; - poolPath = other1043.poolPath; - __isset = other1043.__isset; +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1053) { + resourcePlanName = other1053.resourcePlanName; + poolPath = other1053.poolPath; + __isset = other1053.__isset; } -WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1044) { - resourcePlanName = other1044.resourcePlanName; - poolPath = other1044.poolPath; - __isset = other1044.__isset; +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1054) { + resourcePlanName = other1054.resourcePlanName; + poolPath = other1054.poolPath; + __isset = other1054.__isset; return *this; } void WMDropPoolRequest::printTo(std::ostream& out) const { @@ -26091,11 +26377,11 @@ void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) { (void) b; } -WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1045) { - (void) other1045; +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1055) { + (void) other1055; } -WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1046) { - (void) other1046; +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1056) { + (void) other1056; return *this; } void WMDropPoolResponse::printTo(std::ostream& out) const { @@ -26195,15 +26481,15 @@ void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) swap(a.__isset, b.__isset); } -WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1047) { - mapping = other1047.mapping; - update = other1047.update; - __isset = other1047.__isset; +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1057) { + mapping = other1057.mapping; + update = other1057.update; + __isset = other1057.__isset; } -WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1048) { - mapping = other1048.mapping; - update = other1048.update; - __isset = other1048.__isset; +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1058) { + mapping = other1058.mapping; + update = other1058.update; + __isset = other1058.__isset; return *this; } void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { @@ -26263,11 +26549,11 @@ void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b (void) b; } -WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1049) { - (void) other1049; +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1059) { + (void) other1059; } -WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1050) { - (void) other1050; +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1060) { + (void) other1060; return *this; } void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { @@ -26348,13 +26634,13 @@ void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) { swap(a.__isset, b.__isset); } -WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1051) { - mapping = other1051.mapping; - __isset = other1051.__isset; +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1061) { + mapping = other1061.mapping; + __isset = other1061.__isset; } -WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1052) { - mapping = other1052.mapping; - __isset = other1052.__isset; +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1062) { + mapping = other1062.mapping; + __isset = other1062.__isset; return *this; } void WMDropMappingRequest::printTo(std::ostream& out) const { @@ -26413,11 +26699,11 @@ void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) { (void) b; } -WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1053) { - (void) other1053; +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1063) { + (void) other1063; } -WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1054) { - (void) other1054; +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1064) { + (void) other1064; return *this; } void WMDropMappingResponse::printTo(std::ostream& out) const { @@ -26555,19 +26841,19 @@ void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToP swap(a.__isset, b.__isset); } -WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1055) { - resourcePlanName = other1055.resourcePlanName; - triggerName = other1055.triggerName; - poolPath = other1055.poolPath; - drop = other1055.drop; - __isset = other1055.__isset; +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1065) { + resourcePlanName = other1065.resourcePlanName; + triggerName = other1065.triggerName; + poolPath = other1065.poolPath; + drop = other1065.drop; + __isset = other1065.__isset; } -WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1056) { - resourcePlanName = other1056.resourcePlanName; - triggerName = other1056.triggerName; - poolPath = other1056.poolPath; - drop = other1056.drop; - __isset = other1056.__isset; +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1066) { + resourcePlanName = other1066.resourcePlanName; + triggerName = other1066.triggerName; + poolPath = other1066.poolPath; + drop = other1066.drop; + __isset = other1066.__isset; return *this; } void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { @@ -26629,11 +26915,11 @@ void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerTo (void) b; } -WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1057) { - (void) other1057; +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1067) { + (void) other1067; } -WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1058) { - (void) other1058; +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1068) { + (void) other1068; return *this; } void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { @@ -26712,13 +26998,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other1059) : TException() { - message = other1059.message; - __isset = other1059.__isset; +MetaException::MetaException(const MetaException& other1069) : TException() { + message = other1069.message; + __isset = other1069.__isset; } -MetaException& MetaException::operator=(const MetaException& other1060) { - message = other1060.message; - __isset = other1060.__isset; +MetaException& MetaException::operator=(const MetaException& other1070) { + message = other1070.message; + __isset = other1070.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -26809,13 +27095,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other1061) : TException() { - message = other1061.message; - __isset = other1061.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other1071) : TException() { + message = other1071.message; + __isset = other1071.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1062) { - message = other1062.message; - __isset = other1062.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1072) { + message = other1072.message; + __isset = other1072.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -26906,13 +27192,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other1063) : TException() { - message = other1063.message; - __isset = other1063.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other1073) : TException() { + message = other1073.message; + __isset = other1073.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1064) { - message = other1064.message; - __isset = other1064.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1074) { + message = other1074.message; + __isset = other1074.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -27003,13 +27289,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1065) : TException() { - message = other1065.message; - __isset = other1065.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1075) : TException() { + message = other1075.message; + __isset = other1075.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1066) { - message = other1066.message; - __isset = other1066.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1076) { + message = other1076.message; + __isset = other1076.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -27100,13 +27386,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1067) : TException() { - message = other1067.message; - __isset = other1067.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1077) : TException() { + message = other1077.message; + __isset = other1077.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1068) { - message = other1068.message; - __isset = other1068.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1078) { + message = other1078.message; + __isset = other1078.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -27197,13 +27483,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1069) : TException() { - message = other1069.message; - __isset = other1069.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1079) : TException() { + message = other1079.message; + __isset = other1079.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1070) { - message = other1070.message; - __isset = other1070.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1080) { + message = other1080.message; + __isset = other1080.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -27294,13 +27580,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1071) : TException() { - message = other1071.message; - __isset = other1071.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1081) : TException() { + message = other1081.message; + __isset = other1081.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1072) { - message = other1072.message; - __isset = other1072.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1082) { + message = other1082.message; + __isset = other1082.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -27391,13 +27677,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1073) : TException() { - message = other1073.message; - __isset = other1073.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1083) : TException() { + message = other1083.message; + __isset = other1083.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1074) { - message = other1074.message; - __isset = other1074.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1084) { + message = other1084.message; + __isset = other1084.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -27488,13 +27774,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other1075) : TException() { - message = other1075.message; - __isset = other1075.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other1085) : TException() { + message = other1085.message; + __isset = other1085.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other1076) { - message = other1076.message; - __isset = other1076.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other1086) { + message = other1086.message; + __isset = other1086.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -27585,13 +27871,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1077) : TException() { - message = other1077.message; - __isset = other1077.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1087) : TException() { + message = other1087.message; + __isset = other1087.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1078) { - message = other1078.message; - __isset = other1078.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1088) { + message = other1088.message; + __isset = other1088.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -27682,13 +27968,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1079) : TException() { - message = other1079.message; - __isset = other1079.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1089) : TException() { + message = other1089.message; + __isset = other1089.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1080) { - message = other1080.message; - __isset = other1080.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1090) { + message = other1090.message; + __isset = other1090.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -27779,13 +28065,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other1081) : TException() { - message = other1081.message; - __isset = other1081.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other1091) : TException() { + message = other1091.message; + __isset = other1091.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1082) { - message = other1082.message; - __isset = other1082.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1092) { + message = other1092.message; + __isset = other1092.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -27876,13 +28162,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1083) : TException() { - message = other1083.message; - __isset = other1083.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1093) : TException() { + message = other1093.message; + __isset = other1093.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1084) { - message = other1084.message; - __isset = other1084.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1094) { + message = other1094.message; + __isset = other1094.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -27973,13 +28259,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1085) : TException() { - message = other1085.message; - __isset = other1085.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1095) : TException() { + message = other1095.message; + __isset = other1095.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1086) { - message = other1086.message; - __isset = other1086.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1096) { + message = other1096.message; + __isset = other1096.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -28070,13 +28356,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other1087) : TException() { - message = other1087.message; - __isset = other1087.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other1097) : TException() { + message = other1097.message; + __isset = other1097.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1088) { - message = other1088.message; - __isset = other1088.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1098) { + message = other1098.message; + __isset = other1098.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -28167,13 +28453,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1089) : TException() { - message = other1089.message; - __isset = other1089.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1099) : TException() { + message = other1099.message; + __isset = other1099.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1090) { - message = other1090.message; - __isset = other1090.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1100) { + message = other1100.message; + __isset = other1100.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 835cbb3308..d48b697be8 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -364,6 +364,10 @@ class AbortTxnsRequest; class CommitTxnRequest; +class GetTargetTxnIdRequest; + +class GetTargetTxnIdResponse; + class GetValidWriteIdsRequest; class TableValidWriteIds; @@ -5744,8 +5748,10 @@ inline std::ostream& operator<<(std::ostream& out, const GetOpenTxnsResponse& ob } typedef struct _OpenTxnRequest__isset { - _OpenTxnRequest__isset() : agentInfo(true) {} + _OpenTxnRequest__isset() : agentInfo(true), replPolicy(false), replSrcTxnId(false) {} bool agentInfo :1; + bool replPolicy :1; + bool replSrcTxnId :1; } _OpenTxnRequest__isset; class OpenTxnRequest { @@ -5753,7 +5759,7 @@ class OpenTxnRequest { OpenTxnRequest(const OpenTxnRequest&); OpenTxnRequest& operator=(const OpenTxnRequest&); - OpenTxnRequest() : num_txns(0), user(), hostname(), agentInfo("Unknown") { + OpenTxnRequest() : num_txns(0), user(), hostname(), agentInfo("Unknown"), replPolicy() { } virtual ~OpenTxnRequest() throw(); @@ -5761,6 +5767,8 @@ class OpenTxnRequest { std::string user; std::string hostname; std::string agentInfo; + std::string replPolicy; + std::vector replSrcTxnId; _OpenTxnRequest__isset __isset; @@ -5772,6 +5780,10 @@ class OpenTxnRequest { void __set_agentInfo(const std::string& val); + void __set_replPolicy(const std::string& val); + + void __set_replSrcTxnId(const std::vector & val); + bool operator == (const OpenTxnRequest & rhs) const { if (!(num_txns == rhs.num_txns)) @@ -5784,6 +5796,14 @@ class OpenTxnRequest { return false; else if (__isset.agentInfo && !(agentInfo == rhs.agentInfo)) return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; + if (__isset.replSrcTxnId != rhs.__isset.replSrcTxnId) + return false; + else if (__isset.replSrcTxnId && !(replSrcTxnId == rhs.replSrcTxnId)) + return false; return true; } bool operator != (const OpenTxnRequest &rhs) const { @@ -5846,24 +5866,37 @@ inline std::ostream& operator<<(std::ostream& out, const OpenTxnsResponse& obj) return out; } +typedef struct _AbortTxnRequest__isset { + _AbortTxnRequest__isset() : replPolicy(false) {} + bool replPolicy :1; +} _AbortTxnRequest__isset; class AbortTxnRequest { public: AbortTxnRequest(const AbortTxnRequest&); AbortTxnRequest& operator=(const AbortTxnRequest&); - AbortTxnRequest() : txnid(0) { + AbortTxnRequest() : txnid(0), replPolicy() { } virtual ~AbortTxnRequest() throw(); int64_t txnid; + std::string replPolicy; + + _AbortTxnRequest__isset __isset; void __set_txnid(const int64_t val); + void __set_replPolicy(const std::string& val); + bool operator == (const AbortTxnRequest & rhs) const { if (!(txnid == rhs.txnid)) return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; return true; } bool operator != (const AbortTxnRequest &rhs) const { @@ -5926,24 +5959,37 @@ inline std::ostream& operator<<(std::ostream& out, const AbortTxnsRequest& obj) return out; } +typedef struct _CommitTxnRequest__isset { + _CommitTxnRequest__isset() : replPolicy(false) {} + bool replPolicy :1; +} _CommitTxnRequest__isset; class CommitTxnRequest { public: CommitTxnRequest(const CommitTxnRequest&); CommitTxnRequest& operator=(const CommitTxnRequest&); - CommitTxnRequest() : txnid(0) { + CommitTxnRequest() : txnid(0), replPolicy() { } virtual ~CommitTxnRequest() throw(); int64_t txnid; + std::string replPolicy; + + _CommitTxnRequest__isset __isset; void __set_txnid(const int64_t val); + void __set_replPolicy(const std::string& val); + bool operator == (const CommitTxnRequest & rhs) const { if (!(txnid == rhs.txnid)) return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; return true; } bool operator != (const CommitTxnRequest &rhs) const { @@ -5967,6 +6013,86 @@ inline std::ostream& operator<<(std::ostream& out, const CommitTxnRequest& obj) } +class GetTargetTxnIdRequest { + public: + + GetTargetTxnIdRequest(const GetTargetTxnIdRequest&); + GetTargetTxnIdRequest& operator=(const GetTargetTxnIdRequest&); + GetTargetTxnIdRequest() : txnid(0) { + } + + virtual ~GetTargetTxnIdRequest() throw(); + int64_t txnid; + + void __set_txnid(const int64_t val); + + bool operator == (const GetTargetTxnIdRequest & rhs) const + { + if (!(txnid == rhs.txnid)) + return false; + return true; + } + bool operator != (const GetTargetTxnIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTargetTxnIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTargetTxnIdRequest &a, GetTargetTxnIdRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const GetTargetTxnIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class GetTargetTxnIdResponse { + public: + + GetTargetTxnIdResponse(const GetTargetTxnIdResponse&); + GetTargetTxnIdResponse& operator=(const GetTargetTxnIdResponse&); + GetTargetTxnIdResponse() : txnid(0) { + } + + virtual ~GetTargetTxnIdResponse() throw(); + int64_t txnid; + + void __set_txnid(const int64_t val); + + bool operator == (const GetTargetTxnIdResponse & rhs) const + { + if (!(txnid == rhs.txnid)) + return false; + return true; + } + bool operator != (const GetTargetTxnIdResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTargetTxnIdResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTargetTxnIdResponse &a, GetTargetTxnIdResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const GetTargetTxnIdResponse& obj) +{ + obj.printTo(out); + return out; +} + + class GetValidWriteIdsRequest { public: diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnRequest.java index d6c68fe67a..3530f2bce1 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnRequest.java @@ -39,6 +39,7 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AbortTxnRequest"); private static final org.apache.thrift.protocol.TField TXNID_FIELD_DESC = new org.apache.thrift.protocol.TField("txnid", org.apache.thrift.protocol.TType.I64, (short)1); + private static final org.apache.thrift.protocol.TField REPL_POLICY_FIELD_DESC = new org.apache.thrift.protocol.TField("replPolicy", org.apache.thrift.protocol.TType.STRING, (short)2); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -47,10 +48,12 @@ } private long txnid; // required + private String replPolicy; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - TXNID((short)1, "txnid"); + TXNID((short)1, "txnid"), + REPL_POLICY((short)2, "replPolicy"); private static final Map byName = new HashMap(); @@ -67,6 +70,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // TXNID return TXNID; + case 2: // REPL_POLICY + return REPL_POLICY; default: return null; } @@ -109,11 +114,14 @@ public String getFieldName() { // isset id assignments private static final int __TXNID_ISSET_ID = 0; private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.REPL_POLICY}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.TXNID, new org.apache.thrift.meta_data.FieldMetaData("txnid", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.REPL_POLICY, new org.apache.thrift.meta_data.FieldMetaData("replPolicy", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AbortTxnRequest.class, metaDataMap); } @@ -135,6 +143,9 @@ public AbortTxnRequest( public AbortTxnRequest(AbortTxnRequest other) { __isset_bitfield = other.__isset_bitfield; this.txnid = other.txnid; + if (other.isSetReplPolicy()) { + this.replPolicy = other.replPolicy; + } } public AbortTxnRequest deepCopy() { @@ -145,6 +156,7 @@ public AbortTxnRequest deepCopy() { public void clear() { setTxnidIsSet(false); this.txnid = 0; + this.replPolicy = null; } public long getTxnid() { @@ -169,6 +181,29 @@ public void setTxnidIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TXNID_ISSET_ID, value); } + public String getReplPolicy() { + return this.replPolicy; + } + + public void setReplPolicy(String replPolicy) { + this.replPolicy = replPolicy; + } + + public void unsetReplPolicy() { + this.replPolicy = null; + } + + /** Returns true if field replPolicy is set (has been assigned a value) and false otherwise */ + public boolean isSetReplPolicy() { + return this.replPolicy != null; + } + + public void setReplPolicyIsSet(boolean value) { + if (!value) { + this.replPolicy = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TXNID: @@ -179,6 +214,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case REPL_POLICY: + if (value == null) { + unsetReplPolicy(); + } else { + setReplPolicy((String)value); + } + break; + } } @@ -187,6 +230,9 @@ public Object getFieldValue(_Fields field) { case TXNID: return getTxnid(); + case REPL_POLICY: + return getReplPolicy(); + } throw new IllegalStateException(); } @@ -200,6 +246,8 @@ public boolean isSet(_Fields field) { switch (field) { case TXNID: return isSetTxnid(); + case REPL_POLICY: + return isSetReplPolicy(); } throw new IllegalStateException(); } @@ -226,6 +274,15 @@ public boolean equals(AbortTxnRequest that) { return false; } + boolean this_present_replPolicy = true && this.isSetReplPolicy(); + boolean that_present_replPolicy = true && that.isSetReplPolicy(); + if (this_present_replPolicy || that_present_replPolicy) { + if (!(this_present_replPolicy && that_present_replPolicy)) + return false; + if (!this.replPolicy.equals(that.replPolicy)) + return false; + } + return true; } @@ -238,6 +295,11 @@ public int hashCode() { if (present_txnid) list.add(txnid); + boolean present_replPolicy = true && (isSetReplPolicy()); + list.add(present_replPolicy); + if (present_replPolicy) + list.add(replPolicy); + return list.hashCode(); } @@ -259,6 +321,16 @@ public int compareTo(AbortTxnRequest other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetReplPolicy()).compareTo(other.isSetReplPolicy()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReplPolicy()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.replPolicy, other.replPolicy); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -282,6 +354,16 @@ public String toString() { sb.append("txnid:"); sb.append(this.txnid); first = false; + if (isSetReplPolicy()) { + if (!first) sb.append(", "); + sb.append("replPolicy:"); + if (this.replPolicy == null) { + sb.append("null"); + } else { + sb.append(this.replPolicy); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -339,6 +421,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AbortTxnRequest str org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // REPL_POLICY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -355,6 +445,13 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AbortTxnRequest st oprot.writeFieldBegin(TXNID_FIELD_DESC); oprot.writeI64(struct.txnid); oprot.writeFieldEnd(); + if (struct.replPolicy != null) { + if (struct.isSetReplPolicy()) { + oprot.writeFieldBegin(REPL_POLICY_FIELD_DESC); + oprot.writeString(struct.replPolicy); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -373,6 +470,14 @@ public AbortTxnRequestTupleScheme getScheme() { public void write(org.apache.thrift.protocol.TProtocol prot, AbortTxnRequest struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeI64(struct.txnid); + BitSet optionals = new BitSet(); + if (struct.isSetReplPolicy()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetReplPolicy()) { + oprot.writeString(struct.replPolicy); + } } @Override @@ -380,6 +485,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, AbortTxnRequest stru TTupleProtocol iprot = (TTupleProtocol) prot; struct.txnid = iprot.readI64(); struct.setTxnidIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } } } diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnsRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnsRequest.java index 0e5dbf7ae6..dd76bb7306 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnsRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AbortTxnsRequest.java @@ -351,13 +351,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AbortTxnsRequest st case 1: // TXN_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list548 = iprot.readListBegin(); - struct.txn_ids = new ArrayList(_list548.size); - long _elem549; - for (int _i550 = 0; _i550 < _list548.size; ++_i550) + org.apache.thrift.protocol.TList _list556 = iprot.readListBegin(); + struct.txn_ids = new ArrayList(_list556.size); + long _elem557; + for (int _i558 = 0; _i558 < _list556.size; ++_i558) { - _elem549 = iprot.readI64(); - struct.txn_ids.add(_elem549); + _elem557 = iprot.readI64(); + struct.txn_ids.add(_elem557); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AbortTxnsRequest s oprot.writeFieldBegin(TXN_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.txn_ids.size())); - for (long _iter551 : struct.txn_ids) + for (long _iter559 : struct.txn_ids) { - oprot.writeI64(_iter551); + oprot.writeI64(_iter559); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AbortTxnsRequest st TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.txn_ids.size()); - for (long _iter552 : struct.txn_ids) + for (long _iter560 : struct.txn_ids) { - oprot.writeI64(_iter552); + oprot.writeI64(_iter560); } } } @@ -421,13 +421,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AbortTxnsRequest st public void read(org.apache.thrift.protocol.TProtocol prot, AbortTxnsRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list553 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.txn_ids = new ArrayList(_list553.size); - long _elem554; - for (int _i555 = 0; _i555 < _list553.size; ++_i555) + org.apache.thrift.protocol.TList _list561 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.txn_ids = new ArrayList(_list561.size); + long _elem562; + for (int _i563 = 0; _i563 < _list561.size; ++_i563) { - _elem554 = iprot.readI64(); - struct.txn_ids.add(_elem554); + _elem562 = iprot.readI64(); + struct.txn_ids.add(_elem562); } } struct.setTxn_idsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java index a01dc2463c..d151e2dd51 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddDynamicPartitions.java @@ -816,13 +816,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AddDynamicPartition case 5: // PARTITIONNAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list646 = iprot.readListBegin(); - struct.partitionnames = new ArrayList(_list646.size); - String _elem647; - for (int _i648 = 0; _i648 < _list646.size; ++_i648) + org.apache.thrift.protocol.TList _list654 = iprot.readListBegin(); + struct.partitionnames = new ArrayList(_list654.size); + String _elem655; + for (int _i656 = 0; _i656 < _list654.size; ++_i656) { - _elem647 = iprot.readString(); - struct.partitionnames.add(_elem647); + _elem655 = iprot.readString(); + struct.partitionnames.add(_elem655); } iprot.readListEnd(); } @@ -872,9 +872,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AddDynamicPartitio oprot.writeFieldBegin(PARTITIONNAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partitionnames.size())); - for (String _iter649 : struct.partitionnames) + for (String _iter657 : struct.partitionnames) { - oprot.writeString(_iter649); + oprot.writeString(_iter657); } oprot.writeListEnd(); } @@ -910,9 +910,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AddDynamicPartition oprot.writeString(struct.tablename); { oprot.writeI32(struct.partitionnames.size()); - for (String _iter650 : struct.partitionnames) + for (String _iter658 : struct.partitionnames) { - oprot.writeString(_iter650); + oprot.writeString(_iter658); } } BitSet optionals = new BitSet(); @@ -937,13 +937,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, AddDynamicPartitions struct.tablename = iprot.readString(); struct.setTablenameIsSet(true); { - org.apache.thrift.protocol.TList _list651 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionnames = new ArrayList(_list651.size); - String _elem652; - for (int _i653 = 0; _i653 < _list651.size; ++_i653) + org.apache.thrift.protocol.TList _list659 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionnames = new ArrayList(_list659.size); + String _elem660; + for (int _i661 = 0; _i661 < _list659.size; ++_i661) { - _elem652 = iprot.readString(); - struct.partitionnames.add(_elem652); + _elem660 = iprot.readString(); + struct.partitionnames.add(_elem660); } } struct.setPartitionnamesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsRequest.java index 1aec53bd4c..758f894837 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsRequest.java @@ -521,13 +521,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AllocateTableWriteI case 1: // TXN_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list580 = iprot.readListBegin(); - struct.txnIds = new ArrayList(_list580.size); - long _elem581; - for (int _i582 = 0; _i582 < _list580.size; ++_i582) + org.apache.thrift.protocol.TList _list588 = iprot.readListBegin(); + struct.txnIds = new ArrayList(_list588.size); + long _elem589; + for (int _i590 = 0; _i590 < _list588.size; ++_i590) { - _elem581 = iprot.readI64(); - struct.txnIds.add(_elem581); + _elem589 = iprot.readI64(); + struct.txnIds.add(_elem589); } iprot.readListEnd(); } @@ -569,9 +569,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AllocateTableWrite oprot.writeFieldBegin(TXN_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.txnIds.size())); - for (long _iter583 : struct.txnIds) + for (long _iter591 : struct.txnIds) { - oprot.writeI64(_iter583); + oprot.writeI64(_iter591); } oprot.writeListEnd(); } @@ -606,9 +606,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteI TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.txnIds.size()); - for (long _iter584 : struct.txnIds) + for (long _iter592 : struct.txnIds) { - oprot.writeI64(_iter584); + oprot.writeI64(_iter592); } } oprot.writeString(struct.dbName); @@ -619,13 +619,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteI public void read(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteIdsRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list585 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.txnIds = new ArrayList(_list585.size); - long _elem586; - for (int _i587 = 0; _i587 < _list585.size; ++_i587) + org.apache.thrift.protocol.TList _list593 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.txnIds = new ArrayList(_list593.size); + long _elem594; + for (int _i595 = 0; _i595 < _list593.size; ++_i595) { - _elem586 = iprot.readI64(); - struct.txnIds.add(_elem586); + _elem594 = iprot.readI64(); + struct.txnIds.add(_elem594); } } struct.setTxnIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsResponse.java index e29e1db6b6..782e2789aa 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AllocateTableWriteIdsResponse.java @@ -354,14 +354,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, AllocateTableWriteI case 1: // TXN_TO_WRITE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list588 = iprot.readListBegin(); - struct.txnToWriteIds = new ArrayList(_list588.size); - TxnToWriteId _elem589; - for (int _i590 = 0; _i590 < _list588.size; ++_i590) + org.apache.thrift.protocol.TList _list596 = iprot.readListBegin(); + struct.txnToWriteIds = new ArrayList(_list596.size); + TxnToWriteId _elem597; + for (int _i598 = 0; _i598 < _list596.size; ++_i598) { - _elem589 = new TxnToWriteId(); - _elem589.read(iprot); - struct.txnToWriteIds.add(_elem589); + _elem597 = new TxnToWriteId(); + _elem597.read(iprot); + struct.txnToWriteIds.add(_elem597); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, AllocateTableWrite oprot.writeFieldBegin(TXN_TO_WRITE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.txnToWriteIds.size())); - for (TxnToWriteId _iter591 : struct.txnToWriteIds) + for (TxnToWriteId _iter599 : struct.txnToWriteIds) { - _iter591.write(oprot); + _iter599.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteI TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.txnToWriteIds.size()); - for (TxnToWriteId _iter592 : struct.txnToWriteIds) + for (TxnToWriteId _iter600 : struct.txnToWriteIds) { - _iter592.write(oprot); + _iter600.write(oprot); } } } @@ -425,14 +425,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteI public void read(org.apache.thrift.protocol.TProtocol prot, AllocateTableWriteIdsResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list593 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.txnToWriteIds = new ArrayList(_list593.size); - TxnToWriteId _elem594; - for (int _i595 = 0; _i595 < _list593.size; ++_i595) + org.apache.thrift.protocol.TList _list601 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.txnToWriteIds = new ArrayList(_list601.size); + TxnToWriteId _elem602; + for (int _i603 = 0; _i603 < _list601.size; ++_i603) { - _elem594 = new TxnToWriteId(); - _elem594.read(iprot); - struct.txnToWriteIds.add(_elem594); + _elem602 = new TxnToWriteId(); + _elem602.read(iprot); + struct.txnToWriteIds.add(_elem602); } } struct.setTxnToWriteIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClearFileMetadataRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClearFileMetadataRequest.java index ee9841f650..c0d984be61 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClearFileMetadataRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClearFileMetadataRequest.java @@ -351,13 +351,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ClearFileMetadataRe case 1: // FILE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list746 = iprot.readListBegin(); - struct.fileIds = new ArrayList(_list746.size); - long _elem747; - for (int _i748 = 0; _i748 < _list746.size; ++_i748) + org.apache.thrift.protocol.TList _list754 = iprot.readListBegin(); + struct.fileIds = new ArrayList(_list754.size); + long _elem755; + for (int _i756 = 0; _i756 < _list754.size; ++_i756) { - _elem747 = iprot.readI64(); - struct.fileIds.add(_elem747); + _elem755 = iprot.readI64(); + struct.fileIds.add(_elem755); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ClearFileMetadataR oprot.writeFieldBegin(FILE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.fileIds.size())); - for (long _iter749 : struct.fileIds) + for (long _iter757 : struct.fileIds) { - oprot.writeI64(_iter749); + oprot.writeI64(_iter757); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ClearFileMetadataRe TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fileIds.size()); - for (long _iter750 : struct.fileIds) + for (long _iter758 : struct.fileIds) { - oprot.writeI64(_iter750); + oprot.writeI64(_iter758); } } } @@ -421,13 +421,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ClearFileMetadataRe public void read(org.apache.thrift.protocol.TProtocol prot, ClearFileMetadataRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list751 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.fileIds = new ArrayList(_list751.size); - long _elem752; - for (int _i753 = 0; _i753 < _list751.size; ++_i753) + org.apache.thrift.protocol.TList _list759 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.fileIds = new ArrayList(_list759.size); + long _elem760; + for (int _i761 = 0; _i761 < _list759.size; ++_i761) { - _elem752 = iprot.readI64(); - struct.fileIds.add(_elem752); + _elem760 = iprot.readI64(); + struct.fileIds.add(_elem760); } } struct.setFileIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java index 8dbe4c1d44..413dcc9e1d 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java @@ -354,13 +354,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ClientCapabilities case 1: // VALUES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list762 = iprot.readListBegin(); - struct.values = new ArrayList(_list762.size); - ClientCapability _elem763; - for (int _i764 = 0; _i764 < _list762.size; ++_i764) + org.apache.thrift.protocol.TList _list770 = iprot.readListBegin(); + struct.values = new ArrayList(_list770.size); + ClientCapability _elem771; + for (int _i772 = 0; _i772 < _list770.size; ++_i772) { - _elem763 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32()); - struct.values.add(_elem763); + _elem771 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32()); + struct.values.add(_elem771); } iprot.readListEnd(); } @@ -386,9 +386,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ClientCapabilities oprot.writeFieldBegin(VALUES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.values.size())); - for (ClientCapability _iter765 : struct.values) + for (ClientCapability _iter773 : struct.values) { - oprot.writeI32(_iter765.getValue()); + oprot.writeI32(_iter773.getValue()); } oprot.writeListEnd(); } @@ -413,9 +413,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.values.size()); - for (ClientCapability _iter766 : struct.values) + for (ClientCapability _iter774 : struct.values) { - oprot.writeI32(_iter766.getValue()); + oprot.writeI32(_iter774.getValue()); } } } @@ -424,13 +424,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities public void read(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list767 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.values = new ArrayList(_list767.size); - ClientCapability _elem768; - for (int _i769 = 0; _i769 < _list767.size; ++_i769) + org.apache.thrift.protocol.TList _list775 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.values = new ArrayList(_list775.size); + ClientCapability _elem776; + for (int _i777 = 0; _i777 < _list775.size; ++_i777) { - _elem768 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32()); - struct.values.add(_elem768); + _elem776 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32()); + struct.values.add(_elem776); } } struct.setValuesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CommitTxnRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CommitTxnRequest.java index 17e6e9ce98..3c15f84942 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CommitTxnRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CommitTxnRequest.java @@ -39,6 +39,7 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CommitTxnRequest"); private static final org.apache.thrift.protocol.TField TXNID_FIELD_DESC = new org.apache.thrift.protocol.TField("txnid", org.apache.thrift.protocol.TType.I64, (short)1); + private static final org.apache.thrift.protocol.TField REPL_POLICY_FIELD_DESC = new org.apache.thrift.protocol.TField("replPolicy", org.apache.thrift.protocol.TType.STRING, (short)2); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -47,10 +48,12 @@ } private long txnid; // required + private String replPolicy; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - TXNID((short)1, "txnid"); + TXNID((short)1, "txnid"), + REPL_POLICY((short)2, "replPolicy"); private static final Map byName = new HashMap(); @@ -67,6 +70,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // TXNID return TXNID; + case 2: // REPL_POLICY + return REPL_POLICY; default: return null; } @@ -109,11 +114,14 @@ public String getFieldName() { // isset id assignments private static final int __TXNID_ISSET_ID = 0; private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.REPL_POLICY}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.TXNID, new org.apache.thrift.meta_data.FieldMetaData("txnid", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.REPL_POLICY, new org.apache.thrift.meta_data.FieldMetaData("replPolicy", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CommitTxnRequest.class, metaDataMap); } @@ -135,6 +143,9 @@ public CommitTxnRequest( public CommitTxnRequest(CommitTxnRequest other) { __isset_bitfield = other.__isset_bitfield; this.txnid = other.txnid; + if (other.isSetReplPolicy()) { + this.replPolicy = other.replPolicy; + } } public CommitTxnRequest deepCopy() { @@ -145,6 +156,7 @@ public CommitTxnRequest deepCopy() { public void clear() { setTxnidIsSet(false); this.txnid = 0; + this.replPolicy = null; } public long getTxnid() { @@ -169,6 +181,29 @@ public void setTxnidIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TXNID_ISSET_ID, value); } + public String getReplPolicy() { + return this.replPolicy; + } + + public void setReplPolicy(String replPolicy) { + this.replPolicy = replPolicy; + } + + public void unsetReplPolicy() { + this.replPolicy = null; + } + + /** Returns true if field replPolicy is set (has been assigned a value) and false otherwise */ + public boolean isSetReplPolicy() { + return this.replPolicy != null; + } + + public void setReplPolicyIsSet(boolean value) { + if (!value) { + this.replPolicy = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TXNID: @@ -179,6 +214,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case REPL_POLICY: + if (value == null) { + unsetReplPolicy(); + } else { + setReplPolicy((String)value); + } + break; + } } @@ -187,6 +230,9 @@ public Object getFieldValue(_Fields field) { case TXNID: return getTxnid(); + case REPL_POLICY: + return getReplPolicy(); + } throw new IllegalStateException(); } @@ -200,6 +246,8 @@ public boolean isSet(_Fields field) { switch (field) { case TXNID: return isSetTxnid(); + case REPL_POLICY: + return isSetReplPolicy(); } throw new IllegalStateException(); } @@ -226,6 +274,15 @@ public boolean equals(CommitTxnRequest that) { return false; } + boolean this_present_replPolicy = true && this.isSetReplPolicy(); + boolean that_present_replPolicy = true && that.isSetReplPolicy(); + if (this_present_replPolicy || that_present_replPolicy) { + if (!(this_present_replPolicy && that_present_replPolicy)) + return false; + if (!this.replPolicy.equals(that.replPolicy)) + return false; + } + return true; } @@ -238,6 +295,11 @@ public int hashCode() { if (present_txnid) list.add(txnid); + boolean present_replPolicy = true && (isSetReplPolicy()); + list.add(present_replPolicy); + if (present_replPolicy) + list.add(replPolicy); + return list.hashCode(); } @@ -259,6 +321,16 @@ public int compareTo(CommitTxnRequest other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetReplPolicy()).compareTo(other.isSetReplPolicy()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReplPolicy()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.replPolicy, other.replPolicy); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -282,6 +354,16 @@ public String toString() { sb.append("txnid:"); sb.append(this.txnid); first = false; + if (isSetReplPolicy()) { + if (!first) sb.append(", "); + sb.append("replPolicy:"); + if (this.replPolicy == null) { + sb.append("null"); + } else { + sb.append(this.replPolicy); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -339,6 +421,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, CommitTxnRequest st org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // REPL_POLICY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -355,6 +445,13 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, CommitTxnRequest s oprot.writeFieldBegin(TXNID_FIELD_DESC); oprot.writeI64(struct.txnid); oprot.writeFieldEnd(); + if (struct.replPolicy != null) { + if (struct.isSetReplPolicy()) { + oprot.writeFieldBegin(REPL_POLICY_FIELD_DESC); + oprot.writeString(struct.replPolicy); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -373,6 +470,14 @@ public CommitTxnRequestTupleScheme getScheme() { public void write(org.apache.thrift.protocol.TProtocol prot, CommitTxnRequest struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeI64(struct.txnid); + BitSet optionals = new BitSet(); + if (struct.isSetReplPolicy()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetReplPolicy()) { + oprot.writeString(struct.replPolicy); + } } @Override @@ -380,6 +485,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, CommitTxnRequest str TTupleProtocol iprot = (TTupleProtocol) prot; struct.txnid = iprot.readI64(); struct.setTxnidIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } } } diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CompactionRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CompactionRequest.java index 1853720368..5b7dc63731 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CompactionRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CompactionRequest.java @@ -814,15 +814,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, CompactionRequest s case 6: // PROPERTIES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map628 = iprot.readMapBegin(); - struct.properties = new HashMap(2*_map628.size); - String _key629; - String _val630; - for (int _i631 = 0; _i631 < _map628.size; ++_i631) + org.apache.thrift.protocol.TMap _map636 = iprot.readMapBegin(); + struct.properties = new HashMap(2*_map636.size); + String _key637; + String _val638; + for (int _i639 = 0; _i639 < _map636.size; ++_i639) { - _key629 = iprot.readString(); - _val630 = iprot.readString(); - struct.properties.put(_key629, _val630); + _key637 = iprot.readString(); + _val638 = iprot.readString(); + struct.properties.put(_key637, _val638); } iprot.readMapEnd(); } @@ -878,10 +878,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, CompactionRequest oprot.writeFieldBegin(PROPERTIES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.properties.size())); - for (Map.Entry _iter632 : struct.properties.entrySet()) + for (Map.Entry _iter640 : struct.properties.entrySet()) { - oprot.writeString(_iter632.getKey()); - oprot.writeString(_iter632.getValue()); + oprot.writeString(_iter640.getKey()); + oprot.writeString(_iter640.getValue()); } oprot.writeMapEnd(); } @@ -928,10 +928,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, CompactionRequest s if (struct.isSetProperties()) { { oprot.writeI32(struct.properties.size()); - for (Map.Entry _iter633 : struct.properties.entrySet()) + for (Map.Entry _iter641 : struct.properties.entrySet()) { - oprot.writeString(_iter633.getKey()); - oprot.writeString(_iter633.getValue()); + oprot.writeString(_iter641.getKey()); + oprot.writeString(_iter641.getValue()); } } } @@ -957,15 +957,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, CompactionRequest st } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map634 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.properties = new HashMap(2*_map634.size); - String _key635; - String _val636; - for (int _i637 = 0; _i637 < _map634.size; ++_i637) + org.apache.thrift.protocol.TMap _map642 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.properties = new HashMap(2*_map642.size); + String _key643; + String _val644; + for (int _i645 = 0; _i645 < _map642.size; ++_i645) { - _key635 = iprot.readString(); - _val636 = iprot.readString(); - struct.properties.put(_key635, _val636); + _key643 = iprot.readString(); + _val644 = iprot.readString(); + struct.properties.put(_key643, _val644); } } struct.setPropertiesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CreationMetadata.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CreationMetadata.java index 717840fa0b..dc2cffdb3a 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CreationMetadata.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CreationMetadata.java @@ -619,13 +619,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, CreationMetadata st case 3: // TABLES_USED if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set654 = iprot.readSetBegin(); - struct.tablesUsed = new HashSet(2*_set654.size); - String _elem655; - for (int _i656 = 0; _i656 < _set654.size; ++_i656) + org.apache.thrift.protocol.TSet _set662 = iprot.readSetBegin(); + struct.tablesUsed = new HashSet(2*_set662.size); + String _elem663; + for (int _i664 = 0; _i664 < _set662.size; ++_i664) { - _elem655 = iprot.readString(); - struct.tablesUsed.add(_elem655); + _elem663 = iprot.readString(); + struct.tablesUsed.add(_elem663); } iprot.readSetEnd(); } @@ -669,9 +669,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, CreationMetadata s oprot.writeFieldBegin(TABLES_USED_FIELD_DESC); { oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.tablesUsed.size())); - for (String _iter657 : struct.tablesUsed) + for (String _iter665 : struct.tablesUsed) { - oprot.writeString(_iter657); + oprot.writeString(_iter665); } oprot.writeSetEnd(); } @@ -705,9 +705,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, CreationMetadata st oprot.writeString(struct.tblName); { oprot.writeI32(struct.tablesUsed.size()); - for (String _iter658 : struct.tablesUsed) + for (String _iter666 : struct.tablesUsed) { - oprot.writeString(_iter658); + oprot.writeString(_iter666); } } BitSet optionals = new BitSet(); @@ -728,13 +728,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, CreationMetadata str struct.tblName = iprot.readString(); struct.setTblNameIsSet(true); { - org.apache.thrift.protocol.TSet _set659 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tablesUsed = new HashSet(2*_set659.size); - String _elem660; - for (int _i661 = 0; _i661 < _set659.size; ++_i661) + org.apache.thrift.protocol.TSet _set667 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tablesUsed = new HashSet(2*_set667.size); + String _elem668; + for (int _i669 = 0; _i669 < _set667.size; ++_i669) { - _elem660 = iprot.readString(); - struct.tablesUsed.add(_elem660); + _elem668 = iprot.readString(); + struct.tablesUsed.add(_elem668); } } struct.setTablesUsedIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FireEventRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FireEventRequest.java index 8936410e23..062db61045 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FireEventRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FireEventRequest.java @@ -713,13 +713,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, FireEventRequest st case 5: // PARTITION_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list686 = iprot.readListBegin(); - struct.partitionVals = new ArrayList(_list686.size); - String _elem687; - for (int _i688 = 0; _i688 < _list686.size; ++_i688) + org.apache.thrift.protocol.TList _list694 = iprot.readListBegin(); + struct.partitionVals = new ArrayList(_list694.size); + String _elem695; + for (int _i696 = 0; _i696 < _list694.size; ++_i696) { - _elem687 = iprot.readString(); - struct.partitionVals.add(_elem687); + _elem695 = iprot.readString(); + struct.partitionVals.add(_elem695); } iprot.readListEnd(); } @@ -768,9 +768,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, FireEventRequest s oprot.writeFieldBegin(PARTITION_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partitionVals.size())); - for (String _iter689 : struct.partitionVals) + for (String _iter697 : struct.partitionVals) { - oprot.writeString(_iter689); + oprot.writeString(_iter697); } oprot.writeListEnd(); } @@ -816,9 +816,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, FireEventRequest st if (struct.isSetPartitionVals()) { { oprot.writeI32(struct.partitionVals.size()); - for (String _iter690 : struct.partitionVals) + for (String _iter698 : struct.partitionVals) { - oprot.writeString(_iter690); + oprot.writeString(_iter698); } } } @@ -843,13 +843,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, FireEventRequest str } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list691 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionVals = new ArrayList(_list691.size); - String _elem692; - for (int _i693 = 0; _i693 < _list691.size; ++_i693) + org.apache.thrift.protocol.TList _list699 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionVals = new ArrayList(_list699.size); + String _elem700; + for (int _i701 = 0; _i701 < _list699.size; ++_i701) { - _elem692 = iprot.readString(); - struct.partitionVals.add(_elem692); + _elem700 = iprot.readString(); + struct.partitionVals.add(_elem700); } } struct.setPartitionValsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java index ba29e90299..3546e7f85c 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java @@ -346,14 +346,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetAllFunctionsResp case 1: // FUNCTIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list754 = iprot.readListBegin(); - struct.functions = new ArrayList(_list754.size); - Function _elem755; - for (int _i756 = 0; _i756 < _list754.size; ++_i756) + org.apache.thrift.protocol.TList _list762 = iprot.readListBegin(); + struct.functions = new ArrayList(_list762.size); + Function _elem763; + for (int _i764 = 0; _i764 < _list762.size; ++_i764) { - _elem755 = new Function(); - _elem755.read(iprot); - struct.functions.add(_elem755); + _elem763 = new Function(); + _elem763.read(iprot); + struct.functions.add(_elem763); } iprot.readListEnd(); } @@ -380,9 +380,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetAllFunctionsRes oprot.writeFieldBegin(FUNCTIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.functions.size())); - for (Function _iter757 : struct.functions) + for (Function _iter765 : struct.functions) { - _iter757.write(oprot); + _iter765.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetAllFunctionsResp if (struct.isSetFunctions()) { { oprot.writeI32(struct.functions.size()); - for (Function _iter758 : struct.functions) + for (Function _iter766 : struct.functions) { - _iter758.write(oprot); + _iter766.write(oprot); } } } @@ -428,14 +428,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetAllFunctionsRespo BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list759 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.functions = new ArrayList(_list759.size); - Function _elem760; - for (int _i761 = 0; _i761 < _list759.size; ++_i761) + org.apache.thrift.protocol.TList _list767 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.functions = new ArrayList(_list767.size); + Function _elem768; + for (int _i769 = 0; _i769 < _list767.size; ++_i769) { - _elem760 = new Function(); - _elem760.read(iprot); - struct.functions.add(_elem760); + _elem768 = new Function(); + _elem768.read(iprot); + struct.functions.add(_elem768); } } struct.setFunctionsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprRequest.java index 62b0768d10..57ef796641 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprRequest.java @@ -619,13 +619,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetFileMetadataByEx case 1: // FILE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list704 = iprot.readListBegin(); - struct.fileIds = new ArrayList(_list704.size); - long _elem705; - for (int _i706 = 0; _i706 < _list704.size; ++_i706) + org.apache.thrift.protocol.TList _list712 = iprot.readListBegin(); + struct.fileIds = new ArrayList(_list712.size); + long _elem713; + for (int _i714 = 0; _i714 < _list712.size; ++_i714) { - _elem705 = iprot.readI64(); - struct.fileIds.add(_elem705); + _elem713 = iprot.readI64(); + struct.fileIds.add(_elem713); } iprot.readListEnd(); } @@ -675,9 +675,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetFileMetadataByE oprot.writeFieldBegin(FILE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.fileIds.size())); - for (long _iter707 : struct.fileIds) + for (long _iter715 : struct.fileIds) { - oprot.writeI64(_iter707); + oprot.writeI64(_iter715); } oprot.writeListEnd(); } @@ -719,9 +719,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByEx TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fileIds.size()); - for (long _iter708 : struct.fileIds) + for (long _iter716 : struct.fileIds) { - oprot.writeI64(_iter708); + oprot.writeI64(_iter716); } } oprot.writeBinary(struct.expr); @@ -745,13 +745,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByEx public void read(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByExprRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list709 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.fileIds = new ArrayList(_list709.size); - long _elem710; - for (int _i711 = 0; _i711 < _list709.size; ++_i711) + org.apache.thrift.protocol.TList _list717 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.fileIds = new ArrayList(_list717.size); + long _elem718; + for (int _i719 = 0; _i719 < _list717.size; ++_i719) { - _elem710 = iprot.readI64(); - struct.fileIds.add(_elem710); + _elem718 = iprot.readI64(); + struct.fileIds.add(_elem718); } } struct.setFileIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprResult.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprResult.java index 881803fea0..17c4d716e9 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprResult.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataByExprResult.java @@ -444,16 +444,16 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetFileMetadataByEx case 1: // METADATA if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map694 = iprot.readMapBegin(); - struct.metadata = new HashMap(2*_map694.size); - long _key695; - MetadataPpdResult _val696; - for (int _i697 = 0; _i697 < _map694.size; ++_i697) + org.apache.thrift.protocol.TMap _map702 = iprot.readMapBegin(); + struct.metadata = new HashMap(2*_map702.size); + long _key703; + MetadataPpdResult _val704; + for (int _i705 = 0; _i705 < _map702.size; ++_i705) { - _key695 = iprot.readI64(); - _val696 = new MetadataPpdResult(); - _val696.read(iprot); - struct.metadata.put(_key695, _val696); + _key703 = iprot.readI64(); + _val704 = new MetadataPpdResult(); + _val704.read(iprot); + struct.metadata.put(_key703, _val704); } iprot.readMapEnd(); } @@ -487,10 +487,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetFileMetadataByE oprot.writeFieldBegin(METADATA_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, struct.metadata.size())); - for (Map.Entry _iter698 : struct.metadata.entrySet()) + for (Map.Entry _iter706 : struct.metadata.entrySet()) { - oprot.writeI64(_iter698.getKey()); - _iter698.getValue().write(oprot); + oprot.writeI64(_iter706.getKey()); + _iter706.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -518,10 +518,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByEx TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.metadata.size()); - for (Map.Entry _iter699 : struct.metadata.entrySet()) + for (Map.Entry _iter707 : struct.metadata.entrySet()) { - oprot.writeI64(_iter699.getKey()); - _iter699.getValue().write(oprot); + oprot.writeI64(_iter707.getKey()); + _iter707.getValue().write(oprot); } } oprot.writeBool(struct.isSupported); @@ -531,16 +531,16 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByEx public void read(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataByExprResult struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TMap _map700 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.metadata = new HashMap(2*_map700.size); - long _key701; - MetadataPpdResult _val702; - for (int _i703 = 0; _i703 < _map700.size; ++_i703) + org.apache.thrift.protocol.TMap _map708 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.metadata = new HashMap(2*_map708.size); + long _key709; + MetadataPpdResult _val710; + for (int _i711 = 0; _i711 < _map708.size; ++_i711) { - _key701 = iprot.readI64(); - _val702 = new MetadataPpdResult(); - _val702.read(iprot); - struct.metadata.put(_key701, _val702); + _key709 = iprot.readI64(); + _val710 = new MetadataPpdResult(); + _val710.read(iprot); + struct.metadata.put(_key709, _val710); } } struct.setMetadataIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataRequest.java index a051fb08b3..7197c31ed6 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataRequest.java @@ -351,13 +351,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetFileMetadataRequ case 1: // FILE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list722 = iprot.readListBegin(); - struct.fileIds = new ArrayList(_list722.size); - long _elem723; - for (int _i724 = 0; _i724 < _list722.size; ++_i724) + org.apache.thrift.protocol.TList _list730 = iprot.readListBegin(); + struct.fileIds = new ArrayList(_list730.size); + long _elem731; + for (int _i732 = 0; _i732 < _list730.size; ++_i732) { - _elem723 = iprot.readI64(); - struct.fileIds.add(_elem723); + _elem731 = iprot.readI64(); + struct.fileIds.add(_elem731); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetFileMetadataReq oprot.writeFieldBegin(FILE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.fileIds.size())); - for (long _iter725 : struct.fileIds) + for (long _iter733 : struct.fileIds) { - oprot.writeI64(_iter725); + oprot.writeI64(_iter733); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataRequ TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fileIds.size()); - for (long _iter726 : struct.fileIds) + for (long _iter734 : struct.fileIds) { - oprot.writeI64(_iter726); + oprot.writeI64(_iter734); } } } @@ -421,13 +421,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataRequ public void read(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list727 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.fileIds = new ArrayList(_list727.size); - long _elem728; - for (int _i729 = 0; _i729 < _list727.size; ++_i729) + org.apache.thrift.protocol.TList _list735 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.fileIds = new ArrayList(_list735.size); + long _elem736; + for (int _i737 = 0; _i737 < _list735.size; ++_i737) { - _elem728 = iprot.readI64(); - struct.fileIds.add(_elem728); + _elem736 = iprot.readI64(); + struct.fileIds.add(_elem736); } } struct.setFileIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataResult.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataResult.java index 74ca66ae4f..e1554b4138 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataResult.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFileMetadataResult.java @@ -433,15 +433,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetFileMetadataResu case 1: // METADATA if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map712 = iprot.readMapBegin(); - struct.metadata = new HashMap(2*_map712.size); - long _key713; - ByteBuffer _val714; - for (int _i715 = 0; _i715 < _map712.size; ++_i715) + org.apache.thrift.protocol.TMap _map720 = iprot.readMapBegin(); + struct.metadata = new HashMap(2*_map720.size); + long _key721; + ByteBuffer _val722; + for (int _i723 = 0; _i723 < _map720.size; ++_i723) { - _key713 = iprot.readI64(); - _val714 = iprot.readBinary(); - struct.metadata.put(_key713, _val714); + _key721 = iprot.readI64(); + _val722 = iprot.readBinary(); + struct.metadata.put(_key721, _val722); } iprot.readMapEnd(); } @@ -475,10 +475,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetFileMetadataRes oprot.writeFieldBegin(METADATA_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, struct.metadata.size())); - for (Map.Entry _iter716 : struct.metadata.entrySet()) + for (Map.Entry _iter724 : struct.metadata.entrySet()) { - oprot.writeI64(_iter716.getKey()); - oprot.writeBinary(_iter716.getValue()); + oprot.writeI64(_iter724.getKey()); + oprot.writeBinary(_iter724.getValue()); } oprot.writeMapEnd(); } @@ -506,10 +506,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataResu TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.metadata.size()); - for (Map.Entry _iter717 : struct.metadata.entrySet()) + for (Map.Entry _iter725 : struct.metadata.entrySet()) { - oprot.writeI64(_iter717.getKey()); - oprot.writeBinary(_iter717.getValue()); + oprot.writeI64(_iter725.getKey()); + oprot.writeBinary(_iter725.getValue()); } } oprot.writeBool(struct.isSupported); @@ -519,15 +519,15 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataResu public void read(org.apache.thrift.protocol.TProtocol prot, GetFileMetadataResult struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TMap _map718 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.metadata = new HashMap(2*_map718.size); - long _key719; - ByteBuffer _val720; - for (int _i721 = 0; _i721 < _map718.size; ++_i721) + org.apache.thrift.protocol.TMap _map726 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.metadata = new HashMap(2*_map726.size); + long _key727; + ByteBuffer _val728; + for (int _i729 = 0; _i729 < _map726.size; ++_i729) { - _key719 = iprot.readI64(); - _val720 = iprot.readBinary(); - struct.metadata.put(_key719, _val720); + _key727 = iprot.readI64(); + _val728 = iprot.readBinary(); + struct.metadata.put(_key727, _val728); } } struct.setMetadataIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java index 84af22f413..194f9edc3f 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java @@ -525,13 +525,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetTablesRequest st case 2: // TBL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list770 = iprot.readListBegin(); - struct.tblNames = new ArrayList(_list770.size); - String _elem771; - for (int _i772 = 0; _i772 < _list770.size; ++_i772) + org.apache.thrift.protocol.TList _list778 = iprot.readListBegin(); + struct.tblNames = new ArrayList(_list778.size); + String _elem779; + for (int _i780 = 0; _i780 < _list778.size; ++_i780) { - _elem771 = iprot.readString(); - struct.tblNames.add(_elem771); + _elem779 = iprot.readString(); + struct.tblNames.add(_elem779); } iprot.readListEnd(); } @@ -572,9 +572,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetTablesRequest s oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tblNames.size())); - for (String _iter773 : struct.tblNames) + for (String _iter781 : struct.tblNames) { - oprot.writeString(_iter773); + oprot.writeString(_iter781); } oprot.writeListEnd(); } @@ -617,9 +617,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetTablesRequest st if (struct.isSetTblNames()) { { oprot.writeI32(struct.tblNames.size()); - for (String _iter774 : struct.tblNames) + for (String _iter782 : struct.tblNames) { - oprot.writeString(_iter774); + oprot.writeString(_iter782); } } } @@ -636,13 +636,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetTablesRequest str BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list775 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tblNames = new ArrayList(_list775.size); - String _elem776; - for (int _i777 = 0; _i777 < _list775.size; ++_i777) + org.apache.thrift.protocol.TList _list783 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tblNames = new ArrayList(_list783.size); + String _elem784; + for (int _i785 = 0; _i785 < _list783.size; ++_i785) { - _elem776 = iprot.readString(); - struct.tblNames.add(_elem776); + _elem784 = iprot.readString(); + struct.tblNames.add(_elem784); } } struct.setTblNamesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesResult.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesResult.java index 4aba1d2153..b46086853b 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesResult.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesResult.java @@ -354,14 +354,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetTablesResult str case 1: // TABLES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list778 = iprot.readListBegin(); - struct.tables = new ArrayList
(_list778.size); - Table _elem779; - for (int _i780 = 0; _i780 < _list778.size; ++_i780) + org.apache.thrift.protocol.TList _list786 = iprot.readListBegin(); + struct.tables = new ArrayList
(_list786.size); + Table _elem787; + for (int _i788 = 0; _i788 < _list786.size; ++_i788) { - _elem779 = new Table(); - _elem779.read(iprot); - struct.tables.add(_elem779); + _elem787 = new Table(); + _elem787.read(iprot); + struct.tables.add(_elem787); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetTablesResult st oprot.writeFieldBegin(TABLES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tables.size())); - for (Table _iter781 : struct.tables) + for (Table _iter789 : struct.tables) { - _iter781.write(oprot); + _iter789.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetTablesResult str TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.tables.size()); - for (Table _iter782 : struct.tables) + for (Table _iter790 : struct.tables) { - _iter782.write(oprot); + _iter790.write(oprot); } } } @@ -425,14 +425,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetTablesResult str public void read(org.apache.thrift.protocol.TProtocol prot, GetTablesResult struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list783 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.tables = new ArrayList
(_list783.size); - Table _elem784; - for (int _i785 = 0; _i785 < _list783.size; ++_i785) + org.apache.thrift.protocol.TList _list791 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.tables = new ArrayList
(_list791.size); + Table _elem792; + for (int _i793 = 0; _i793 < _list791.size; ++_i793) { - _elem784 = new Table(); - _elem784.read(iprot); - struct.tables.add(_elem784); + _elem792 = new Table(); + _elem792.read(iprot); + struct.tables.add(_elem792); } } struct.setTablesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdRequest.java new file mode 100644 index 0000000000..9dd3b489d6 --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdRequest.java @@ -0,0 +1,387 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class GetTargetTxnIdRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetTargetTxnIdRequest"); + + private static final org.apache.thrift.protocol.TField TXNID_FIELD_DESC = new org.apache.thrift.protocol.TField("txnid", org.apache.thrift.protocol.TType.I64, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new GetTargetTxnIdRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new GetTargetTxnIdRequestTupleSchemeFactory()); + } + + private long txnid; // 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 { + TXNID((short)1, "txnid"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TXNID + return TXNID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __TXNID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TXNID, new org.apache.thrift.meta_data.FieldMetaData("txnid", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetTargetTxnIdRequest.class, metaDataMap); + } + + public GetTargetTxnIdRequest() { + } + + public GetTargetTxnIdRequest( + long txnid) + { + this(); + this.txnid = txnid; + setTxnidIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public GetTargetTxnIdRequest(GetTargetTxnIdRequest other) { + __isset_bitfield = other.__isset_bitfield; + this.txnid = other.txnid; + } + + public GetTargetTxnIdRequest deepCopy() { + return new GetTargetTxnIdRequest(this); + } + + @Override + public void clear() { + setTxnidIsSet(false); + this.txnid = 0; + } + + public long getTxnid() { + return this.txnid; + } + + public void setTxnid(long txnid) { + this.txnid = txnid; + setTxnidIsSet(true); + } + + public void unsetTxnid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TXNID_ISSET_ID); + } + + /** Returns true if field txnid is set (has been assigned a value) and false otherwise */ + public boolean isSetTxnid() { + return EncodingUtils.testBit(__isset_bitfield, __TXNID_ISSET_ID); + } + + public void setTxnidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TXNID_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TXNID: + if (value == null) { + unsetTxnid(); + } else { + setTxnid((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TXNID: + return getTxnid(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TXNID: + return isSetTxnid(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof GetTargetTxnIdRequest) + return this.equals((GetTargetTxnIdRequest)that); + return false; + } + + public boolean equals(GetTargetTxnIdRequest that) { + if (that == null) + return false; + + boolean this_present_txnid = true; + boolean that_present_txnid = true; + if (this_present_txnid || that_present_txnid) { + if (!(this_present_txnid && that_present_txnid)) + return false; + if (this.txnid != that.txnid) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_txnid = true; + list.add(present_txnid); + if (present_txnid) + list.add(txnid); + + return list.hashCode(); + } + + @Override + public int compareTo(GetTargetTxnIdRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTxnid()).compareTo(other.isSetTxnid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTxnid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.txnid, other.txnid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("GetTargetTxnIdRequest("); + boolean first = true; + + sb.append("txnid:"); + sb.append(this.txnid); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetTxnid()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'txnid' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class GetTargetTxnIdRequestStandardSchemeFactory implements SchemeFactory { + public GetTargetTxnIdRequestStandardScheme getScheme() { + return new GetTargetTxnIdRequestStandardScheme(); + } + } + + private static class GetTargetTxnIdRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, GetTargetTxnIdRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TXNID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.txnid = iprot.readI64(); + struct.setTxnidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, GetTargetTxnIdRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TXNID_FIELD_DESC); + oprot.writeI64(struct.txnid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class GetTargetTxnIdRequestTupleSchemeFactory implements SchemeFactory { + public GetTargetTxnIdRequestTupleScheme getScheme() { + return new GetTargetTxnIdRequestTupleScheme(); + } + } + + private static class GetTargetTxnIdRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, GetTargetTxnIdRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeI64(struct.txnid); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, GetTargetTxnIdRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.txnid = iprot.readI64(); + struct.setTxnidIsSet(true); + } + } + +} + diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdResponse.java new file mode 100644 index 0000000000..2f03c3d965 --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTargetTxnIdResponse.java @@ -0,0 +1,387 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class GetTargetTxnIdResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetTargetTxnIdResponse"); + + private static final org.apache.thrift.protocol.TField TXNID_FIELD_DESC = new org.apache.thrift.protocol.TField("txnid", org.apache.thrift.protocol.TType.I64, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new GetTargetTxnIdResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new GetTargetTxnIdResponseTupleSchemeFactory()); + } + + private long txnid; // 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 { + TXNID((short)1, "txnid"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TXNID + return TXNID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __TXNID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TXNID, new org.apache.thrift.meta_data.FieldMetaData("txnid", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetTargetTxnIdResponse.class, metaDataMap); + } + + public GetTargetTxnIdResponse() { + } + + public GetTargetTxnIdResponse( + long txnid) + { + this(); + this.txnid = txnid; + setTxnidIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public GetTargetTxnIdResponse(GetTargetTxnIdResponse other) { + __isset_bitfield = other.__isset_bitfield; + this.txnid = other.txnid; + } + + public GetTargetTxnIdResponse deepCopy() { + return new GetTargetTxnIdResponse(this); + } + + @Override + public void clear() { + setTxnidIsSet(false); + this.txnid = 0; + } + + public long getTxnid() { + return this.txnid; + } + + public void setTxnid(long txnid) { + this.txnid = txnid; + setTxnidIsSet(true); + } + + public void unsetTxnid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TXNID_ISSET_ID); + } + + /** Returns true if field txnid is set (has been assigned a value) and false otherwise */ + public boolean isSetTxnid() { + return EncodingUtils.testBit(__isset_bitfield, __TXNID_ISSET_ID); + } + + public void setTxnidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TXNID_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TXNID: + if (value == null) { + unsetTxnid(); + } else { + setTxnid((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TXNID: + return getTxnid(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TXNID: + return isSetTxnid(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof GetTargetTxnIdResponse) + return this.equals((GetTargetTxnIdResponse)that); + return false; + } + + public boolean equals(GetTargetTxnIdResponse that) { + if (that == null) + return false; + + boolean this_present_txnid = true; + boolean that_present_txnid = true; + if (this_present_txnid || that_present_txnid) { + if (!(this_present_txnid && that_present_txnid)) + return false; + if (this.txnid != that.txnid) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_txnid = true; + list.add(present_txnid); + if (present_txnid) + list.add(txnid); + + return list.hashCode(); + } + + @Override + public int compareTo(GetTargetTxnIdResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTxnid()).compareTo(other.isSetTxnid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTxnid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.txnid, other.txnid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("GetTargetTxnIdResponse("); + boolean first = true; + + sb.append("txnid:"); + sb.append(this.txnid); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetTxnid()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'txnid' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class GetTargetTxnIdResponseStandardSchemeFactory implements SchemeFactory { + public GetTargetTxnIdResponseStandardScheme getScheme() { + return new GetTargetTxnIdResponseStandardScheme(); + } + } + + private static class GetTargetTxnIdResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, GetTargetTxnIdResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TXNID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.txnid = iprot.readI64(); + struct.setTxnidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, GetTargetTxnIdResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TXNID_FIELD_DESC); + oprot.writeI64(struct.txnid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class GetTargetTxnIdResponseTupleSchemeFactory implements SchemeFactory { + public GetTargetTxnIdResponseTupleScheme getScheme() { + return new GetTargetTxnIdResponseTupleScheme(); + } + } + + private static class GetTargetTxnIdResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, GetTargetTxnIdResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeI64(struct.txnid); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, GetTargetTxnIdResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.txnid = iprot.readI64(); + struct.setTxnidIsSet(true); + } + } + +} + diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java index ec738b0394..c5b34a8fe8 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java @@ -436,13 +436,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetValidWriteIdsReq case 1: // FULL_TABLE_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list556 = iprot.readListBegin(); - struct.fullTableNames = new ArrayList(_list556.size); - String _elem557; - for (int _i558 = 0; _i558 < _list556.size; ++_i558) + org.apache.thrift.protocol.TList _list564 = iprot.readListBegin(); + struct.fullTableNames = new ArrayList(_list564.size); + String _elem565; + for (int _i566 = 0; _i566 < _list564.size; ++_i566) { - _elem557 = iprot.readString(); - struct.fullTableNames.add(_elem557); + _elem565 = iprot.readString(); + struct.fullTableNames.add(_elem565); } iprot.readListEnd(); } @@ -476,9 +476,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetValidWriteIdsRe oprot.writeFieldBegin(FULL_TABLE_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.fullTableNames.size())); - for (String _iter559 : struct.fullTableNames) + for (String _iter567 : struct.fullTableNames) { - oprot.writeString(_iter559); + oprot.writeString(_iter567); } oprot.writeListEnd(); } @@ -508,9 +508,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsReq TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fullTableNames.size()); - for (String _iter560 : struct.fullTableNames) + for (String _iter568 : struct.fullTableNames) { - oprot.writeString(_iter560); + oprot.writeString(_iter568); } } oprot.writeString(struct.validTxnList); @@ -520,13 +520,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsReq public void read(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list561 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.fullTableNames = new ArrayList(_list561.size); - String _elem562; - for (int _i563 = 0; _i563 < _list561.size; ++_i563) + org.apache.thrift.protocol.TList _list569 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.fullTableNames = new ArrayList(_list569.size); + String _elem570; + for (int _i571 = 0; _i571 < _list569.size; ++_i571) { - _elem562 = iprot.readString(); - struct.fullTableNames.add(_elem562); + _elem570 = iprot.readString(); + struct.fullTableNames.add(_elem570); } } struct.setFullTableNamesIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResponse.java index 50eba33a27..5203329d26 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResponse.java @@ -354,14 +354,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetValidWriteIdsRes case 1: // TBL_VALID_WRITE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list572 = iprot.readListBegin(); - struct.tblValidWriteIds = new ArrayList(_list572.size); - TableValidWriteIds _elem573; - for (int _i574 = 0; _i574 < _list572.size; ++_i574) + org.apache.thrift.protocol.TList _list580 = iprot.readListBegin(); + struct.tblValidWriteIds = new ArrayList(_list580.size); + TableValidWriteIds _elem581; + for (int _i582 = 0; _i582 < _list580.size; ++_i582) { - _elem573 = new TableValidWriteIds(); - _elem573.read(iprot); - struct.tblValidWriteIds.add(_elem573); + _elem581 = new TableValidWriteIds(); + _elem581.read(iprot); + struct.tblValidWriteIds.add(_elem581); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetValidWriteIdsRe oprot.writeFieldBegin(TBL_VALID_WRITE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tblValidWriteIds.size())); - for (TableValidWriteIds _iter575 : struct.tblValidWriteIds) + for (TableValidWriteIds _iter583 : struct.tblValidWriteIds) { - _iter575.write(oprot); + _iter583.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsRes TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.tblValidWriteIds.size()); - for (TableValidWriteIds _iter576 : struct.tblValidWriteIds) + for (TableValidWriteIds _iter584 : struct.tblValidWriteIds) { - _iter576.write(oprot); + _iter584.write(oprot); } } } @@ -425,14 +425,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsRes public void read(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list577 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.tblValidWriteIds = new ArrayList(_list577.size); - TableValidWriteIds _elem578; - for (int _i579 = 0; _i579 < _list577.size; ++_i579) + org.apache.thrift.protocol.TList _list585 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.tblValidWriteIds = new ArrayList(_list585.size); + TableValidWriteIds _elem586; + for (int _i587 = 0; _i587 < _list585.size; ++_i587) { - _elem578 = new TableValidWriteIds(); - _elem578.read(iprot); - struct.tblValidWriteIds.add(_elem578); + _elem586 = new TableValidWriteIds(); + _elem586.read(iprot); + struct.tblValidWriteIds.add(_elem586); } } struct.setTblValidWriteIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/HeartbeatTxnRangeResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/HeartbeatTxnRangeResponse.java index 0bcd837235..1c3276c178 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/HeartbeatTxnRangeResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/HeartbeatTxnRangeResponse.java @@ -453,13 +453,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, HeartbeatTxnRangeRe case 1: // ABORTED if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set612 = iprot.readSetBegin(); - struct.aborted = new HashSet(2*_set612.size); - long _elem613; - for (int _i614 = 0; _i614 < _set612.size; ++_i614) + org.apache.thrift.protocol.TSet _set620 = iprot.readSetBegin(); + struct.aborted = new HashSet(2*_set620.size); + long _elem621; + for (int _i622 = 0; _i622 < _set620.size; ++_i622) { - _elem613 = iprot.readI64(); - struct.aborted.add(_elem613); + _elem621 = iprot.readI64(); + struct.aborted.add(_elem621); } iprot.readSetEnd(); } @@ -471,13 +471,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, HeartbeatTxnRangeRe case 2: // NOSUCH if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set615 = iprot.readSetBegin(); - struct.nosuch = new HashSet(2*_set615.size); - long _elem616; - for (int _i617 = 0; _i617 < _set615.size; ++_i617) + org.apache.thrift.protocol.TSet _set623 = iprot.readSetBegin(); + struct.nosuch = new HashSet(2*_set623.size); + long _elem624; + for (int _i625 = 0; _i625 < _set623.size; ++_i625) { - _elem616 = iprot.readI64(); - struct.nosuch.add(_elem616); + _elem624 = iprot.readI64(); + struct.nosuch.add(_elem624); } iprot.readSetEnd(); } @@ -503,9 +503,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, HeartbeatTxnRangeR oprot.writeFieldBegin(ABORTED_FIELD_DESC); { oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, struct.aborted.size())); - for (long _iter618 : struct.aborted) + for (long _iter626 : struct.aborted) { - oprot.writeI64(_iter618); + oprot.writeI64(_iter626); } oprot.writeSetEnd(); } @@ -515,9 +515,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, HeartbeatTxnRangeR oprot.writeFieldBegin(NOSUCH_FIELD_DESC); { oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, struct.nosuch.size())); - for (long _iter619 : struct.nosuch) + for (long _iter627 : struct.nosuch) { - oprot.writeI64(_iter619); + oprot.writeI64(_iter627); } oprot.writeSetEnd(); } @@ -542,16 +542,16 @@ public void write(org.apache.thrift.protocol.TProtocol prot, HeartbeatTxnRangeRe TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.aborted.size()); - for (long _iter620 : struct.aborted) + for (long _iter628 : struct.aborted) { - oprot.writeI64(_iter620); + oprot.writeI64(_iter628); } } { oprot.writeI32(struct.nosuch.size()); - for (long _iter621 : struct.nosuch) + for (long _iter629 : struct.nosuch) { - oprot.writeI64(_iter621); + oprot.writeI64(_iter629); } } } @@ -560,24 +560,24 @@ public void write(org.apache.thrift.protocol.TProtocol prot, HeartbeatTxnRangeRe public void read(org.apache.thrift.protocol.TProtocol prot, HeartbeatTxnRangeResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TSet _set622 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.aborted = new HashSet(2*_set622.size); - long _elem623; - for (int _i624 = 0; _i624 < _set622.size; ++_i624) + org.apache.thrift.protocol.TSet _set630 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.aborted = new HashSet(2*_set630.size); + long _elem631; + for (int _i632 = 0; _i632 < _set630.size; ++_i632) { - _elem623 = iprot.readI64(); - struct.aborted.add(_elem623); + _elem631 = iprot.readI64(); + struct.aborted.add(_elem631); } } struct.setAbortedIsSet(true); { - org.apache.thrift.protocol.TSet _set625 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.nosuch = new HashSet(2*_set625.size); - long _elem626; - for (int _i627 = 0; _i627 < _set625.size; ++_i627) + org.apache.thrift.protocol.TSet _set633 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.nosuch = new HashSet(2*_set633.size); + long _elem634; + for (int _i635 = 0; _i635 < _set633.size; ++_i635) { - _elem626 = iprot.readI64(); - struct.nosuch.add(_elem626); + _elem634 = iprot.readI64(); + struct.nosuch.add(_elem634); } } struct.setNosuchIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InsertEventRequestData.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InsertEventRequestData.java index 85272ddc24..33cfeb782e 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InsertEventRequestData.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InsertEventRequestData.java @@ -538,13 +538,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, InsertEventRequestD case 2: // FILES_ADDED if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list670 = iprot.readListBegin(); - struct.filesAdded = new ArrayList(_list670.size); - String _elem671; - for (int _i672 = 0; _i672 < _list670.size; ++_i672) + org.apache.thrift.protocol.TList _list678 = iprot.readListBegin(); + struct.filesAdded = new ArrayList(_list678.size); + String _elem679; + for (int _i680 = 0; _i680 < _list678.size; ++_i680) { - _elem671 = iprot.readString(); - struct.filesAdded.add(_elem671); + _elem679 = iprot.readString(); + struct.filesAdded.add(_elem679); } iprot.readListEnd(); } @@ -556,13 +556,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, InsertEventRequestD case 3: // FILES_ADDED_CHECKSUM if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list673 = iprot.readListBegin(); - struct.filesAddedChecksum = new ArrayList(_list673.size); - String _elem674; - for (int _i675 = 0; _i675 < _list673.size; ++_i675) + org.apache.thrift.protocol.TList _list681 = iprot.readListBegin(); + struct.filesAddedChecksum = new ArrayList(_list681.size); + String _elem682; + for (int _i683 = 0; _i683 < _list681.size; ++_i683) { - _elem674 = iprot.readString(); - struct.filesAddedChecksum.add(_elem674); + _elem682 = iprot.readString(); + struct.filesAddedChecksum.add(_elem682); } iprot.readListEnd(); } @@ -593,9 +593,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, InsertEventRequest oprot.writeFieldBegin(FILES_ADDED_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.filesAdded.size())); - for (String _iter676 : struct.filesAdded) + for (String _iter684 : struct.filesAdded) { - oprot.writeString(_iter676); + oprot.writeString(_iter684); } oprot.writeListEnd(); } @@ -606,9 +606,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, InsertEventRequest oprot.writeFieldBegin(FILES_ADDED_CHECKSUM_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.filesAddedChecksum.size())); - for (String _iter677 : struct.filesAddedChecksum) + for (String _iter685 : struct.filesAddedChecksum) { - oprot.writeString(_iter677); + oprot.writeString(_iter685); } oprot.writeListEnd(); } @@ -634,9 +634,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, InsertEventRequestD TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.filesAdded.size()); - for (String _iter678 : struct.filesAdded) + for (String _iter686 : struct.filesAdded) { - oprot.writeString(_iter678); + oprot.writeString(_iter686); } } BitSet optionals = new BitSet(); @@ -653,9 +653,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, InsertEventRequestD if (struct.isSetFilesAddedChecksum()) { { oprot.writeI32(struct.filesAddedChecksum.size()); - for (String _iter679 : struct.filesAddedChecksum) + for (String _iter687 : struct.filesAddedChecksum) { - oprot.writeString(_iter679); + oprot.writeString(_iter687); } } } @@ -665,13 +665,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, InsertEventRequestD public void read(org.apache.thrift.protocol.TProtocol prot, InsertEventRequestData struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list680 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.filesAdded = new ArrayList(_list680.size); - String _elem681; - for (int _i682 = 0; _i682 < _list680.size; ++_i682) + org.apache.thrift.protocol.TList _list688 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.filesAdded = new ArrayList(_list688.size); + String _elem689; + for (int _i690 = 0; _i690 < _list688.size; ++_i690) { - _elem681 = iprot.readString(); - struct.filesAdded.add(_elem681); + _elem689 = iprot.readString(); + struct.filesAdded.add(_elem689); } } struct.setFilesAddedIsSet(true); @@ -682,13 +682,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, InsertEventRequestDa } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list683 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.filesAddedChecksum = new ArrayList(_list683.size); - String _elem684; - for (int _i685 = 0; _i685 < _list683.size; ++_i685) + org.apache.thrift.protocol.TList _list691 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.filesAddedChecksum = new ArrayList(_list691.size); + String _elem692; + for (int _i693 = 0; _i693 < _list691.size; ++_i693) { - _elem684 = iprot.readString(); - struct.filesAddedChecksum.add(_elem684); + _elem692 = iprot.readString(); + struct.filesAddedChecksum.add(_elem692); } } struct.setFilesAddedChecksumIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockRequest.java index cfdd0bdf76..1977f3b2af 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockRequest.java @@ -689,14 +689,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, LockRequest struct) case 1: // COMPONENT if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list596 = iprot.readListBegin(); - struct.component = new ArrayList(_list596.size); - LockComponent _elem597; - for (int _i598 = 0; _i598 < _list596.size; ++_i598) + org.apache.thrift.protocol.TList _list604 = iprot.readListBegin(); + struct.component = new ArrayList(_list604.size); + LockComponent _elem605; + for (int _i606 = 0; _i606 < _list604.size; ++_i606) { - _elem597 = new LockComponent(); - _elem597.read(iprot); - struct.component.add(_elem597); + _elem605 = new LockComponent(); + _elem605.read(iprot); + struct.component.add(_elem605); } iprot.readListEnd(); } @@ -754,9 +754,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, LockRequest struct oprot.writeFieldBegin(COMPONENT_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.component.size())); - for (LockComponent _iter599 : struct.component) + for (LockComponent _iter607 : struct.component) { - _iter599.write(oprot); + _iter607.write(oprot); } oprot.writeListEnd(); } @@ -803,9 +803,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, LockRequest struct) TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.component.size()); - for (LockComponent _iter600 : struct.component) + for (LockComponent _iter608 : struct.component) { - _iter600.write(oprot); + _iter608.write(oprot); } } oprot.writeString(struct.user); @@ -830,14 +830,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, LockRequest struct) public void read(org.apache.thrift.protocol.TProtocol prot, LockRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list601 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.component = new ArrayList(_list601.size); - LockComponent _elem602; - for (int _i603 = 0; _i603 < _list601.size; ++_i603) + org.apache.thrift.protocol.TList _list609 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.component = new ArrayList(_list609.size); + LockComponent _elem610; + for (int _i611 = 0; _i611 < _list609.size; ++_i611) { - _elem602 = new LockComponent(); - _elem602.read(iprot); - struct.component.add(_elem602); + _elem610 = new LockComponent(); + _elem610.read(iprot); + struct.component.add(_elem610); } } struct.setComponentIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Materialization.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Materialization.java index c91b9cfea9..21ce20e1d8 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Materialization.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Materialization.java @@ -518,13 +518,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, Materialization str case 1: // TABLES_USED if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set786 = iprot.readSetBegin(); - struct.tablesUsed = new HashSet(2*_set786.size); - String _elem787; - for (int _i788 = 0; _i788 < _set786.size; ++_i788) + org.apache.thrift.protocol.TSet _set794 = iprot.readSetBegin(); + struct.tablesUsed = new HashSet(2*_set794.size); + String _elem795; + for (int _i796 = 0; _i796 < _set794.size; ++_i796) { - _elem787 = iprot.readString(); - struct.tablesUsed.add(_elem787); + _elem795 = iprot.readString(); + struct.tablesUsed.add(_elem795); } iprot.readSetEnd(); } @@ -566,9 +566,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, Materialization st oprot.writeFieldBegin(TABLES_USED_FIELD_DESC); { oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.tablesUsed.size())); - for (String _iter789 : struct.tablesUsed) + for (String _iter797 : struct.tablesUsed) { - oprot.writeString(_iter789); + oprot.writeString(_iter797); } oprot.writeSetEnd(); } @@ -603,9 +603,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, Materialization str TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.tablesUsed.size()); - for (String _iter790 : struct.tablesUsed) + for (String _iter798 : struct.tablesUsed) { - oprot.writeString(_iter790); + oprot.writeString(_iter798); } } oprot.writeI64(struct.invalidationTime); @@ -623,13 +623,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, Materialization str public void read(org.apache.thrift.protocol.TProtocol prot, Materialization struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TSet _set791 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tablesUsed = new HashSet(2*_set791.size); - String _elem792; - for (int _i793 = 0; _i793 < _set791.size; ++_i793) + org.apache.thrift.protocol.TSet _set799 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tablesUsed = new HashSet(2*_set799.size); + String _elem800; + for (int _i801 = 0; _i801 < _set799.size; ++_i801) { - _elem792 = iprot.readString(); - struct.tablesUsed.add(_elem792); + _elem800 = iprot.readString(); + struct.tablesUsed.add(_elem800); } } struct.setTablesUsedIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java index 549c14b119..4440a8e478 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java @@ -354,14 +354,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, NotificationEventRe case 1: // EVENTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list662 = iprot.readListBegin(); - struct.events = new ArrayList(_list662.size); - NotificationEvent _elem663; - for (int _i664 = 0; _i664 < _list662.size; ++_i664) + org.apache.thrift.protocol.TList _list670 = iprot.readListBegin(); + struct.events = new ArrayList(_list670.size); + NotificationEvent _elem671; + for (int _i672 = 0; _i672 < _list670.size; ++_i672) { - _elem663 = new NotificationEvent(); - _elem663.read(iprot); - struct.events.add(_elem663); + _elem671 = new NotificationEvent(); + _elem671.read(iprot); + struct.events.add(_elem671); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, NotificationEventR oprot.writeFieldBegin(EVENTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.events.size())); - for (NotificationEvent _iter665 : struct.events) + for (NotificationEvent _iter673 : struct.events) { - _iter665.write(oprot); + _iter673.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, NotificationEventRe TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.events.size()); - for (NotificationEvent _iter666 : struct.events) + for (NotificationEvent _iter674 : struct.events) { - _iter666.write(oprot); + _iter674.write(oprot); } } } @@ -425,14 +425,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, NotificationEventRe public void read(org.apache.thrift.protocol.TProtocol prot, NotificationEventResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list667 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.events = new ArrayList(_list667.size); - NotificationEvent _elem668; - for (int _i669 = 0; _i669 < _list667.size; ++_i669) + org.apache.thrift.protocol.TList _list675 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.events = new ArrayList(_list675.size); + NotificationEvent _elem676; + for (int _i677 = 0; _i677 < _list675.size; ++_i677) { - _elem668 = new NotificationEvent(); - _elem668.read(iprot); - struct.events.add(_elem668); + _elem676 = new NotificationEvent(); + _elem676.read(iprot); + struct.events.add(_elem676); } } struct.setEventsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnRequest.java index 4dd235a080..619579ca3d 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnRequest.java @@ -42,6 +42,8 @@ private static final org.apache.thrift.protocol.TField USER_FIELD_DESC = new org.apache.thrift.protocol.TField("user", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField HOSTNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("hostname", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField AGENT_INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("agentInfo", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField REPL_POLICY_FIELD_DESC = new org.apache.thrift.protocol.TField("replPolicy", org.apache.thrift.protocol.TType.STRING, (short)5); + private static final org.apache.thrift.protocol.TField REPL_SRC_TXN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("replSrcTxnId", org.apache.thrift.protocol.TType.LIST, (short)6); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -53,13 +55,17 @@ private String user; // required private String hostname; // required private String agentInfo; // optional + private String replPolicy; // optional + private List replSrcTxnId; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { NUM_TXNS((short)1, "num_txns"), USER((short)2, "user"), HOSTNAME((short)3, "hostname"), - AGENT_INFO((short)4, "agentInfo"); + AGENT_INFO((short)4, "agentInfo"), + REPL_POLICY((short)5, "replPolicy"), + REPL_SRC_TXN_ID((short)6, "replSrcTxnId"); private static final Map byName = new HashMap(); @@ -82,6 +88,10 @@ public static _Fields findByThriftId(int fieldId) { return HOSTNAME; case 4: // AGENT_INFO return AGENT_INFO; + case 5: // REPL_POLICY + return REPL_POLICY; + case 6: // REPL_SRC_TXN_ID + return REPL_SRC_TXN_ID; default: return null; } @@ -124,7 +134,7 @@ public String getFieldName() { // isset id assignments private static final int __NUM_TXNS_ISSET_ID = 0; private byte __isset_bitfield = 0; - private static final _Fields optionals[] = {_Fields.AGENT_INFO}; + private static final _Fields optionals[] = {_Fields.AGENT_INFO,_Fields.REPL_POLICY,_Fields.REPL_SRC_TXN_ID}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); @@ -136,6 +146,11 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.AGENT_INFO, new org.apache.thrift.meta_data.FieldMetaData("agentInfo", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.REPL_POLICY, new org.apache.thrift.meta_data.FieldMetaData("replPolicy", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.REPL_SRC_TXN_ID, new org.apache.thrift.meta_data.FieldMetaData("replSrcTxnId", org.apache.thrift.TFieldRequirementType.OPTIONAL, + 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)))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OpenTxnRequest.class, metaDataMap); } @@ -172,6 +187,13 @@ public OpenTxnRequest(OpenTxnRequest other) { if (other.isSetAgentInfo()) { this.agentInfo = other.agentInfo; } + if (other.isSetReplPolicy()) { + this.replPolicy = other.replPolicy; + } + if (other.isSetReplSrcTxnId()) { + List __this__replSrcTxnId = new ArrayList(other.replSrcTxnId); + this.replSrcTxnId = __this__replSrcTxnId; + } } public OpenTxnRequest deepCopy() { @@ -186,6 +208,8 @@ public void clear() { this.hostname = null; this.agentInfo = "Unknown"; + this.replPolicy = null; + this.replSrcTxnId = null; } public int getNum_txns() { @@ -279,6 +303,67 @@ public void setAgentInfoIsSet(boolean value) { } } + public String getReplPolicy() { + return this.replPolicy; + } + + public void setReplPolicy(String replPolicy) { + this.replPolicy = replPolicy; + } + + public void unsetReplPolicy() { + this.replPolicy = null; + } + + /** Returns true if field replPolicy is set (has been assigned a value) and false otherwise */ + public boolean isSetReplPolicy() { + return this.replPolicy != null; + } + + public void setReplPolicyIsSet(boolean value) { + if (!value) { + this.replPolicy = null; + } + } + + public int getReplSrcTxnIdSize() { + return (this.replSrcTxnId == null) ? 0 : this.replSrcTxnId.size(); + } + + public java.util.Iterator getReplSrcTxnIdIterator() { + return (this.replSrcTxnId == null) ? null : this.replSrcTxnId.iterator(); + } + + public void addToReplSrcTxnId(long elem) { + if (this.replSrcTxnId == null) { + this.replSrcTxnId = new ArrayList(); + } + this.replSrcTxnId.add(elem); + } + + public List getReplSrcTxnId() { + return this.replSrcTxnId; + } + + public void setReplSrcTxnId(List replSrcTxnId) { + this.replSrcTxnId = replSrcTxnId; + } + + public void unsetReplSrcTxnId() { + this.replSrcTxnId = null; + } + + /** Returns true if field replSrcTxnId is set (has been assigned a value) and false otherwise */ + public boolean isSetReplSrcTxnId() { + return this.replSrcTxnId != null; + } + + public void setReplSrcTxnIdIsSet(boolean value) { + if (!value) { + this.replSrcTxnId = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case NUM_TXNS: @@ -313,6 +398,22 @@ public void setFieldValue(_Fields field, Object value) { } break; + case REPL_POLICY: + if (value == null) { + unsetReplPolicy(); + } else { + setReplPolicy((String)value); + } + break; + + case REPL_SRC_TXN_ID: + if (value == null) { + unsetReplSrcTxnId(); + } else { + setReplSrcTxnId((List)value); + } + break; + } } @@ -330,6 +431,12 @@ public Object getFieldValue(_Fields field) { case AGENT_INFO: return getAgentInfo(); + case REPL_POLICY: + return getReplPolicy(); + + case REPL_SRC_TXN_ID: + return getReplSrcTxnId(); + } throw new IllegalStateException(); } @@ -349,6 +456,10 @@ public boolean isSet(_Fields field) { return isSetHostname(); case AGENT_INFO: return isSetAgentInfo(); + case REPL_POLICY: + return isSetReplPolicy(); + case REPL_SRC_TXN_ID: + return isSetReplSrcTxnId(); } throw new IllegalStateException(); } @@ -402,6 +513,24 @@ public boolean equals(OpenTxnRequest that) { return false; } + boolean this_present_replPolicy = true && this.isSetReplPolicy(); + boolean that_present_replPolicy = true && that.isSetReplPolicy(); + if (this_present_replPolicy || that_present_replPolicy) { + if (!(this_present_replPolicy && that_present_replPolicy)) + return false; + if (!this.replPolicy.equals(that.replPolicy)) + return false; + } + + boolean this_present_replSrcTxnId = true && this.isSetReplSrcTxnId(); + boolean that_present_replSrcTxnId = true && that.isSetReplSrcTxnId(); + if (this_present_replSrcTxnId || that_present_replSrcTxnId) { + if (!(this_present_replSrcTxnId && that_present_replSrcTxnId)) + return false; + if (!this.replSrcTxnId.equals(that.replSrcTxnId)) + return false; + } + return true; } @@ -429,6 +558,16 @@ public int hashCode() { if (present_agentInfo) list.add(agentInfo); + boolean present_replPolicy = true && (isSetReplPolicy()); + list.add(present_replPolicy); + if (present_replPolicy) + list.add(replPolicy); + + boolean present_replSrcTxnId = true && (isSetReplSrcTxnId()); + list.add(present_replSrcTxnId); + if (present_replSrcTxnId) + list.add(replSrcTxnId); + return list.hashCode(); } @@ -480,6 +619,26 @@ public int compareTo(OpenTxnRequest other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetReplPolicy()).compareTo(other.isSetReplPolicy()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReplPolicy()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.replPolicy, other.replPolicy); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetReplSrcTxnId()).compareTo(other.isSetReplSrcTxnId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReplSrcTxnId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.replSrcTxnId, other.replSrcTxnId); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -529,6 +688,26 @@ public String toString() { } first = false; } + if (isSetReplPolicy()) { + if (!first) sb.append(", "); + sb.append("replPolicy:"); + if (this.replPolicy == null) { + sb.append("null"); + } else { + sb.append(this.replPolicy); + } + first = false; + } + if (isSetReplSrcTxnId()) { + if (!first) sb.append(", "); + sb.append("replSrcTxnId:"); + if (this.replSrcTxnId == null) { + sb.append("null"); + } else { + sb.append(this.replSrcTxnId); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -618,6 +797,32 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, OpenTxnRequest stru org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 5: // REPL_POLICY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // REPL_SRC_TXN_ID + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list540 = iprot.readListBegin(); + struct.replSrcTxnId = new ArrayList(_list540.size); + long _elem541; + for (int _i542 = 0; _i542 < _list540.size; ++_i542) + { + _elem541 = iprot.readI64(); + struct.replSrcTxnId.add(_elem541); + } + iprot.readListEnd(); + } + struct.setReplSrcTxnIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -651,6 +856,27 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, OpenTxnRequest str oprot.writeFieldEnd(); } } + if (struct.replPolicy != null) { + if (struct.isSetReplPolicy()) { + oprot.writeFieldBegin(REPL_POLICY_FIELD_DESC); + oprot.writeString(struct.replPolicy); + oprot.writeFieldEnd(); + } + } + if (struct.replSrcTxnId != null) { + if (struct.isSetReplSrcTxnId()) { + oprot.writeFieldBegin(REPL_SRC_TXN_ID_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.replSrcTxnId.size())); + for (long _iter543 : struct.replSrcTxnId) + { + oprot.writeI64(_iter543); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -675,10 +901,28 @@ public void write(org.apache.thrift.protocol.TProtocol prot, OpenTxnRequest stru if (struct.isSetAgentInfo()) { optionals.set(0); } - oprot.writeBitSet(optionals, 1); + if (struct.isSetReplPolicy()) { + optionals.set(1); + } + if (struct.isSetReplSrcTxnId()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); if (struct.isSetAgentInfo()) { oprot.writeString(struct.agentInfo); } + if (struct.isSetReplPolicy()) { + oprot.writeString(struct.replPolicy); + } + if (struct.isSetReplSrcTxnId()) { + { + oprot.writeI32(struct.replSrcTxnId.size()); + for (long _iter544 : struct.replSrcTxnId) + { + oprot.writeI64(_iter544); + } + } + } } @Override @@ -690,11 +934,28 @@ public void read(org.apache.thrift.protocol.TProtocol prot, OpenTxnRequest struc struct.setUserIsSet(true); struct.hostname = iprot.readString(); struct.setHostnameIsSet(true); - BitSet incoming = iprot.readBitSet(1); + BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { struct.agentInfo = iprot.readString(); struct.setAgentInfoIsSet(true); } + if (incoming.get(1)) { + struct.replPolicy = iprot.readString(); + struct.setReplPolicyIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list545 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.replSrcTxnId = new ArrayList(_list545.size); + long _elem546; + for (int _i547 = 0; _i547 < _list545.size; ++_i547) + { + _elem546 = iprot.readI64(); + struct.replSrcTxnId.add(_elem546); + } + } + struct.setReplSrcTxnIdIsSet(true); + } } } diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java index ee7ae396f1..719254fdaa 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java @@ -351,13 +351,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, OpenTxnsResponse st case 1: // TXN_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list540 = iprot.readListBegin(); - struct.txn_ids = new ArrayList(_list540.size); - long _elem541; - for (int _i542 = 0; _i542 < _list540.size; ++_i542) + org.apache.thrift.protocol.TList _list548 = iprot.readListBegin(); + struct.txn_ids = new ArrayList(_list548.size); + long _elem549; + for (int _i550 = 0; _i550 < _list548.size; ++_i550) { - _elem541 = iprot.readI64(); - struct.txn_ids.add(_elem541); + _elem549 = iprot.readI64(); + struct.txn_ids.add(_elem549); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, OpenTxnsResponse s oprot.writeFieldBegin(TXN_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.txn_ids.size())); - for (long _iter543 : struct.txn_ids) + for (long _iter551 : struct.txn_ids) { - oprot.writeI64(_iter543); + oprot.writeI64(_iter551); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, OpenTxnsResponse st TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.txn_ids.size()); - for (long _iter544 : struct.txn_ids) + for (long _iter552 : struct.txn_ids) { - oprot.writeI64(_iter544); + oprot.writeI64(_iter552); } } } @@ -421,13 +421,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, OpenTxnsResponse st public void read(org.apache.thrift.protocol.TProtocol prot, OpenTxnsResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list545 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.txn_ids = new ArrayList(_list545.size); - long _elem546; - for (int _i547 = 0; _i547 < _list545.size; ++_i547) + org.apache.thrift.protocol.TList _list553 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.txn_ids = new ArrayList(_list553.size); + long _elem554; + for (int _i555 = 0; _i555 < _list553.size; ++_i555) { - _elem546 = iprot.readI64(); - struct.txn_ids.add(_elem546); + _elem554 = iprot.readI64(); + struct.txn_ids.add(_elem554); } } struct.setTxn_idsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java index e4089c5f27..7fab667087 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java @@ -547,13 +547,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, PutFileMetadataRequ case 1: // FILE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list730 = iprot.readListBegin(); - struct.fileIds = new ArrayList(_list730.size); - long _elem731; - for (int _i732 = 0; _i732 < _list730.size; ++_i732) + org.apache.thrift.protocol.TList _list738 = iprot.readListBegin(); + struct.fileIds = new ArrayList(_list738.size); + long _elem739; + for (int _i740 = 0; _i740 < _list738.size; ++_i740) { - _elem731 = iprot.readI64(); - struct.fileIds.add(_elem731); + _elem739 = iprot.readI64(); + struct.fileIds.add(_elem739); } iprot.readListEnd(); } @@ -565,13 +565,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, PutFileMetadataRequ case 2: // METADATA if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list733 = iprot.readListBegin(); - struct.metadata = new ArrayList(_list733.size); - ByteBuffer _elem734; - for (int _i735 = 0; _i735 < _list733.size; ++_i735) + org.apache.thrift.protocol.TList _list741 = iprot.readListBegin(); + struct.metadata = new ArrayList(_list741.size); + ByteBuffer _elem742; + for (int _i743 = 0; _i743 < _list741.size; ++_i743) { - _elem734 = iprot.readBinary(); - struct.metadata.add(_elem734); + _elem742 = iprot.readBinary(); + struct.metadata.add(_elem742); } iprot.readListEnd(); } @@ -605,9 +605,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, PutFileMetadataReq oprot.writeFieldBegin(FILE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.fileIds.size())); - for (long _iter736 : struct.fileIds) + for (long _iter744 : struct.fileIds) { - oprot.writeI64(_iter736); + oprot.writeI64(_iter744); } oprot.writeListEnd(); } @@ -617,9 +617,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, PutFileMetadataReq oprot.writeFieldBegin(METADATA_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.metadata.size())); - for (ByteBuffer _iter737 : struct.metadata) + for (ByteBuffer _iter745 : struct.metadata) { - oprot.writeBinary(_iter737); + oprot.writeBinary(_iter745); } oprot.writeListEnd(); } @@ -651,16 +651,16 @@ public void write(org.apache.thrift.protocol.TProtocol prot, PutFileMetadataRequ TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fileIds.size()); - for (long _iter738 : struct.fileIds) + for (long _iter746 : struct.fileIds) { - oprot.writeI64(_iter738); + oprot.writeI64(_iter746); } } { oprot.writeI32(struct.metadata.size()); - for (ByteBuffer _iter739 : struct.metadata) + for (ByteBuffer _iter747 : struct.metadata) { - oprot.writeBinary(_iter739); + oprot.writeBinary(_iter747); } } BitSet optionals = new BitSet(); @@ -677,24 +677,24 @@ public void write(org.apache.thrift.protocol.TProtocol prot, PutFileMetadataRequ public void read(org.apache.thrift.protocol.TProtocol prot, PutFileMetadataRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list740 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.fileIds = new ArrayList(_list740.size); - long _elem741; - for (int _i742 = 0; _i742 < _list740.size; ++_i742) + org.apache.thrift.protocol.TList _list748 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.fileIds = new ArrayList(_list748.size); + long _elem749; + for (int _i750 = 0; _i750 < _list748.size; ++_i750) { - _elem741 = iprot.readI64(); - struct.fileIds.add(_elem741); + _elem749 = iprot.readI64(); + struct.fileIds.add(_elem749); } } struct.setFileIdsIsSet(true); { - org.apache.thrift.protocol.TList _list743 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.metadata = new ArrayList(_list743.size); - ByteBuffer _elem744; - for (int _i745 = 0; _i745 < _list743.size; ++_i745) + org.apache.thrift.protocol.TList _list751 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.metadata = new ArrayList(_list751.size); + ByteBuffer _elem752; + for (int _i753 = 0; _i753 < _list751.size; ++_i753) { - _elem744 = iprot.readBinary(); - struct.metadata.add(_elem744); + _elem752 = iprot.readBinary(); + struct.metadata.add(_elem752); } } struct.setMetadataIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java index fb7b94e965..1883b747f7 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java @@ -354,14 +354,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ShowCompactResponse case 1: // COMPACTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list638 = iprot.readListBegin(); - struct.compacts = new ArrayList(_list638.size); - ShowCompactResponseElement _elem639; - for (int _i640 = 0; _i640 < _list638.size; ++_i640) + org.apache.thrift.protocol.TList _list646 = iprot.readListBegin(); + struct.compacts = new ArrayList(_list646.size); + ShowCompactResponseElement _elem647; + for (int _i648 = 0; _i648 < _list646.size; ++_i648) { - _elem639 = new ShowCompactResponseElement(); - _elem639.read(iprot); - struct.compacts.add(_elem639); + _elem647 = new ShowCompactResponseElement(); + _elem647.read(iprot); + struct.compacts.add(_elem647); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ShowCompactRespons oprot.writeFieldBegin(COMPACTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.compacts.size())); - for (ShowCompactResponseElement _iter641 : struct.compacts) + for (ShowCompactResponseElement _iter649 : struct.compacts) { - _iter641.write(oprot); + _iter649.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ShowCompactResponse TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.compacts.size()); - for (ShowCompactResponseElement _iter642 : struct.compacts) + for (ShowCompactResponseElement _iter650 : struct.compacts) { - _iter642.write(oprot); + _iter650.write(oprot); } } } @@ -425,14 +425,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ShowCompactResponse public void read(org.apache.thrift.protocol.TProtocol prot, ShowCompactResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list643 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.compacts = new ArrayList(_list643.size); - ShowCompactResponseElement _elem644; - for (int _i645 = 0; _i645 < _list643.size; ++_i645) + org.apache.thrift.protocol.TList _list651 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.compacts = new ArrayList(_list651.size); + ShowCompactResponseElement _elem652; + for (int _i653 = 0; _i653 < _list651.size; ++_i653) { - _elem644 = new ShowCompactResponseElement(); - _elem644.read(iprot); - struct.compacts.add(_elem644); + _elem652 = new ShowCompactResponseElement(); + _elem652.read(iprot); + struct.compacts.add(_elem652); } } struct.setCompactsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java index 02dd278fa4..f4748aefd6 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java @@ -350,14 +350,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ShowLocksResponse s case 1: // LOCKS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list604 = iprot.readListBegin(); - struct.locks = new ArrayList(_list604.size); - ShowLocksResponseElement _elem605; - for (int _i606 = 0; _i606 < _list604.size; ++_i606) + org.apache.thrift.protocol.TList _list612 = iprot.readListBegin(); + struct.locks = new ArrayList(_list612.size); + ShowLocksResponseElement _elem613; + for (int _i614 = 0; _i614 < _list612.size; ++_i614) { - _elem605 = new ShowLocksResponseElement(); - _elem605.read(iprot); - struct.locks.add(_elem605); + _elem613 = new ShowLocksResponseElement(); + _elem613.read(iprot); + struct.locks.add(_elem613); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ShowLocksResponse oprot.writeFieldBegin(LOCKS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.locks.size())); - for (ShowLocksResponseElement _iter607 : struct.locks) + for (ShowLocksResponseElement _iter615 : struct.locks) { - _iter607.write(oprot); + _iter615.write(oprot); } oprot.writeListEnd(); } @@ -416,9 +416,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ShowLocksResponse s if (struct.isSetLocks()) { { oprot.writeI32(struct.locks.size()); - for (ShowLocksResponseElement _iter608 : struct.locks) + for (ShowLocksResponseElement _iter616 : struct.locks) { - _iter608.write(oprot); + _iter616.write(oprot); } } } @@ -430,14 +430,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, ShowLocksResponse st BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list609 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.locks = new ArrayList(_list609.size); - ShowLocksResponseElement _elem610; - for (int _i611 = 0; _i611 < _list609.size; ++_i611) + org.apache.thrift.protocol.TList _list617 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.locks = new ArrayList(_list617.size); + ShowLocksResponseElement _elem618; + for (int _i619 = 0; _i619 < _list617.size; ++_i619) { - _elem610 = new ShowLocksResponseElement(); - _elem610.read(iprot); - struct.locks.add(_elem610); + _elem618 = new ShowLocksResponseElement(); + _elem618.read(iprot); + struct.locks.add(_elem618); } } struct.setLocksIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java index 1d43fb84a3..0ee5d9ff1c 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java @@ -708,13 +708,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TableValidWriteIds case 3: // INVALID_WRITE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list564 = iprot.readListBegin(); - struct.invalidWriteIds = new ArrayList(_list564.size); - long _elem565; - for (int _i566 = 0; _i566 < _list564.size; ++_i566) + org.apache.thrift.protocol.TList _list572 = iprot.readListBegin(); + struct.invalidWriteIds = new ArrayList(_list572.size); + long _elem573; + for (int _i574 = 0; _i574 < _list572.size; ++_i574) { - _elem565 = iprot.readI64(); - struct.invalidWriteIds.add(_elem565); + _elem573 = iprot.readI64(); + struct.invalidWriteIds.add(_elem573); } iprot.readListEnd(); } @@ -764,9 +764,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TableValidWriteIds oprot.writeFieldBegin(INVALID_WRITE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.invalidWriteIds.size())); - for (long _iter567 : struct.invalidWriteIds) + for (long _iter575 : struct.invalidWriteIds) { - oprot.writeI64(_iter567); + oprot.writeI64(_iter575); } oprot.writeListEnd(); } @@ -803,9 +803,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TableValidWriteIds oprot.writeI64(struct.writeIdHighWaterMark); { oprot.writeI32(struct.invalidWriteIds.size()); - for (long _iter568 : struct.invalidWriteIds) + for (long _iter576 : struct.invalidWriteIds) { - oprot.writeI64(_iter568); + oprot.writeI64(_iter576); } } oprot.writeBinary(struct.abortedBits); @@ -827,13 +827,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TableValidWriteIds s struct.writeIdHighWaterMark = iprot.readI64(); struct.setWriteIdHighWaterMarkIsSet(true); { - org.apache.thrift.protocol.TList _list569 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.invalidWriteIds = new ArrayList(_list569.size); - long _elem570; - for (int _i571 = 0; _i571 < _list569.size; ++_i571) + org.apache.thrift.protocol.TList _list577 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.invalidWriteIds = new ArrayList(_list577.size); + long _elem578; + for (int _i579 = 0; _i579 < _list577.size; ++_i579) { - _elem570 = iprot.readI64(); - struct.invalidWriteIds.add(_elem570); + _elem578 = iprot.readI64(); + struct.invalidWriteIds.add(_elem578); } } struct.setInvalidWriteIdsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index adddd077ed..625fe80aeb 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -34354,13 +34354,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_databases_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list858 = iprot.readListBegin(); - struct.success = new ArrayList(_list858.size); - String _elem859; - for (int _i860 = 0; _i860 < _list858.size; ++_i860) + org.apache.thrift.protocol.TList _list866 = iprot.readListBegin(); + struct.success = new ArrayList(_list866.size); + String _elem867; + for (int _i868 = 0; _i868 < _list866.size; ++_i868) { - _elem859 = iprot.readString(); - struct.success.add(_elem859); + _elem867 = iprot.readString(); + struct.success.add(_elem867); } iprot.readListEnd(); } @@ -34395,9 +34395,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_databases_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter861 : struct.success) + for (String _iter869 : struct.success) { - oprot.writeString(_iter861); + oprot.writeString(_iter869); } oprot.writeListEnd(); } @@ -34436,9 +34436,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_databases_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter862 : struct.success) + for (String _iter870 : struct.success) { - oprot.writeString(_iter862); + oprot.writeString(_iter870); } } } @@ -34453,13 +34453,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_databases_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list863 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list863.size); - String _elem864; - for (int _i865 = 0; _i865 < _list863.size; ++_i865) + org.apache.thrift.protocol.TList _list871 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list871.size); + String _elem872; + for (int _i873 = 0; _i873 < _list871.size; ++_i873) { - _elem864 = iprot.readString(); - struct.success.add(_elem864); + _elem872 = iprot.readString(); + struct.success.add(_elem872); } } struct.setSuccessIsSet(true); @@ -35113,13 +35113,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_databases_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list866 = iprot.readListBegin(); - struct.success = new ArrayList(_list866.size); - String _elem867; - for (int _i868 = 0; _i868 < _list866.size; ++_i868) + org.apache.thrift.protocol.TList _list874 = iprot.readListBegin(); + struct.success = new ArrayList(_list874.size); + String _elem875; + for (int _i876 = 0; _i876 < _list874.size; ++_i876) { - _elem867 = iprot.readString(); - struct.success.add(_elem867); + _elem875 = iprot.readString(); + struct.success.add(_elem875); } iprot.readListEnd(); } @@ -35154,9 +35154,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_databases_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter869 : struct.success) + for (String _iter877 : struct.success) { - oprot.writeString(_iter869); + oprot.writeString(_iter877); } oprot.writeListEnd(); } @@ -35195,9 +35195,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_databases_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter870 : struct.success) + for (String _iter878 : struct.success) { - oprot.writeString(_iter870); + oprot.writeString(_iter878); } } } @@ -35212,13 +35212,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_databases_re BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list871 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list871.size); - String _elem872; - for (int _i873 = 0; _i873 < _list871.size; ++_i873) + org.apache.thrift.protocol.TList _list879 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list879.size); + String _elem880; + for (int _i881 = 0; _i881 < _list879.size; ++_i881) { - _elem872 = iprot.readString(); - struct.success.add(_elem872); + _elem880 = iprot.readString(); + struct.success.add(_elem880); } } struct.setSuccessIsSet(true); @@ -39825,16 +39825,16 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_type_all_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map874 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map874.size); - String _key875; - Type _val876; - for (int _i877 = 0; _i877 < _map874.size; ++_i877) + org.apache.thrift.protocol.TMap _map882 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map882.size); + String _key883; + Type _val884; + for (int _i885 = 0; _i885 < _map882.size; ++_i885) { - _key875 = iprot.readString(); - _val876 = new Type(); - _val876.read(iprot); - struct.success.put(_key875, _val876); + _key883 = iprot.readString(); + _val884 = new Type(); + _val884.read(iprot); + struct.success.put(_key883, _val884); } iprot.readMapEnd(); } @@ -39869,10 +39869,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_type_all_resul oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Map.Entry _iter878 : struct.success.entrySet()) + for (Map.Entry _iter886 : struct.success.entrySet()) { - oprot.writeString(_iter878.getKey()); - _iter878.getValue().write(oprot); + oprot.writeString(_iter886.getKey()); + _iter886.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -39911,10 +39911,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_type_all_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter879 : struct.success.entrySet()) + for (Map.Entry _iter887 : struct.success.entrySet()) { - oprot.writeString(_iter879.getKey()); - _iter879.getValue().write(oprot); + oprot.writeString(_iter887.getKey()); + _iter887.getValue().write(oprot); } } } @@ -39929,16 +39929,16 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_type_all_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map880 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap(2*_map880.size); - String _key881; - Type _val882; - for (int _i883 = 0; _i883 < _map880.size; ++_i883) + org.apache.thrift.protocol.TMap _map888 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap(2*_map888.size); + String _key889; + Type _val890; + for (int _i891 = 0; _i891 < _map888.size; ++_i891) { - _key881 = iprot.readString(); - _val882 = new Type(); - _val882.read(iprot); - struct.success.put(_key881, _val882); + _key889 = iprot.readString(); + _val890 = new Type(); + _val890.read(iprot); + struct.success.put(_key889, _val890); } } struct.setSuccessIsSet(true); @@ -40973,14 +40973,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_fields_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list884 = iprot.readListBegin(); - struct.success = new ArrayList(_list884.size); - FieldSchema _elem885; - for (int _i886 = 0; _i886 < _list884.size; ++_i886) + org.apache.thrift.protocol.TList _list892 = iprot.readListBegin(); + struct.success = new ArrayList(_list892.size); + FieldSchema _elem893; + for (int _i894 = 0; _i894 < _list892.size; ++_i894) { - _elem885 = new FieldSchema(); - _elem885.read(iprot); - struct.success.add(_elem885); + _elem893 = new FieldSchema(); + _elem893.read(iprot); + struct.success.add(_elem893); } iprot.readListEnd(); } @@ -41033,9 +41033,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_fields_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter887 : struct.success) + for (FieldSchema _iter895 : struct.success) { - _iter887.write(oprot); + _iter895.write(oprot); } oprot.writeListEnd(); } @@ -41090,9 +41090,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter888 : struct.success) + for (FieldSchema _iter896 : struct.success) { - _iter888.write(oprot); + _iter896.write(oprot); } } } @@ -41113,14 +41113,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_result st BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list889 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list889.size); - FieldSchema _elem890; - for (int _i891 = 0; _i891 < _list889.size; ++_i891) + org.apache.thrift.protocol.TList _list897 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list897.size); + FieldSchema _elem898; + for (int _i899 = 0; _i899 < _list897.size; ++_i899) { - _elem890 = new FieldSchema(); - _elem890.read(iprot); - struct.success.add(_elem890); + _elem898 = new FieldSchema(); + _elem898.read(iprot); + struct.success.add(_elem898); } } struct.setSuccessIsSet(true); @@ -42274,14 +42274,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_fields_with_env case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list892 = iprot.readListBegin(); - struct.success = new ArrayList(_list892.size); - FieldSchema _elem893; - for (int _i894 = 0; _i894 < _list892.size; ++_i894) + org.apache.thrift.protocol.TList _list900 = iprot.readListBegin(); + struct.success = new ArrayList(_list900.size); + FieldSchema _elem901; + for (int _i902 = 0; _i902 < _list900.size; ++_i902) { - _elem893 = new FieldSchema(); - _elem893.read(iprot); - struct.success.add(_elem893); + _elem901 = new FieldSchema(); + _elem901.read(iprot); + struct.success.add(_elem901); } iprot.readListEnd(); } @@ -42334,9 +42334,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_fields_with_en oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter895 : struct.success) + for (FieldSchema _iter903 : struct.success) { - _iter895.write(oprot); + _iter903.write(oprot); } oprot.writeListEnd(); } @@ -42391,9 +42391,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter896 : struct.success) + for (FieldSchema _iter904 : struct.success) { - _iter896.write(oprot); + _iter904.write(oprot); } } } @@ -42414,14 +42414,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_with_envi BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list897 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list897.size); - FieldSchema _elem898; - for (int _i899 = 0; _i899 < _list897.size; ++_i899) + org.apache.thrift.protocol.TList _list905 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list905.size); + FieldSchema _elem906; + for (int _i907 = 0; _i907 < _list905.size; ++_i907) { - _elem898 = new FieldSchema(); - _elem898.read(iprot); - struct.success.add(_elem898); + _elem906 = new FieldSchema(); + _elem906.read(iprot); + struct.success.add(_elem906); } } struct.setSuccessIsSet(true); @@ -43466,14 +43466,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_schema_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list900 = iprot.readListBegin(); - struct.success = new ArrayList(_list900.size); - FieldSchema _elem901; - for (int _i902 = 0; _i902 < _list900.size; ++_i902) + org.apache.thrift.protocol.TList _list908 = iprot.readListBegin(); + struct.success = new ArrayList(_list908.size); + FieldSchema _elem909; + for (int _i910 = 0; _i910 < _list908.size; ++_i910) { - _elem901 = new FieldSchema(); - _elem901.read(iprot); - struct.success.add(_elem901); + _elem909 = new FieldSchema(); + _elem909.read(iprot); + struct.success.add(_elem909); } iprot.readListEnd(); } @@ -43526,9 +43526,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_schema_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter903 : struct.success) + for (FieldSchema _iter911 : struct.success) { - _iter903.write(oprot); + _iter911.write(oprot); } oprot.writeListEnd(); } @@ -43583,9 +43583,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter904 : struct.success) + for (FieldSchema _iter912 : struct.success) { - _iter904.write(oprot); + _iter912.write(oprot); } } } @@ -43606,14 +43606,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_result st BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list905 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list905.size); - FieldSchema _elem906; - for (int _i907 = 0; _i907 < _list905.size; ++_i907) + org.apache.thrift.protocol.TList _list913 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list913.size); + FieldSchema _elem914; + for (int _i915 = 0; _i915 < _list913.size; ++_i915) { - _elem906 = new FieldSchema(); - _elem906.read(iprot); - struct.success.add(_elem906); + _elem914 = new FieldSchema(); + _elem914.read(iprot); + struct.success.add(_elem914); } } struct.setSuccessIsSet(true); @@ -44767,14 +44767,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_schema_with_env case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list908 = iprot.readListBegin(); - struct.success = new ArrayList(_list908.size); - FieldSchema _elem909; - for (int _i910 = 0; _i910 < _list908.size; ++_i910) + org.apache.thrift.protocol.TList _list916 = iprot.readListBegin(); + struct.success = new ArrayList(_list916.size); + FieldSchema _elem917; + for (int _i918 = 0; _i918 < _list916.size; ++_i918) { - _elem909 = new FieldSchema(); - _elem909.read(iprot); - struct.success.add(_elem909); + _elem917 = new FieldSchema(); + _elem917.read(iprot); + struct.success.add(_elem917); } iprot.readListEnd(); } @@ -44827,9 +44827,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_schema_with_en oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter911 : struct.success) + for (FieldSchema _iter919 : struct.success) { - _iter911.write(oprot); + _iter919.write(oprot); } oprot.writeListEnd(); } @@ -44884,9 +44884,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter912 : struct.success) + for (FieldSchema _iter920 : struct.success) { - _iter912.write(oprot); + _iter920.write(oprot); } } } @@ -44907,14 +44907,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_with_envi BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list913 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list913.size); - FieldSchema _elem914; - for (int _i915 = 0; _i915 < _list913.size; ++_i915) + org.apache.thrift.protocol.TList _list921 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list921.size); + FieldSchema _elem922; + for (int _i923 = 0; _i923 < _list921.size; ++_i923) { - _elem914 = new FieldSchema(); - _elem914.read(iprot); - struct.success.add(_elem914); + _elem922 = new FieldSchema(); + _elem922.read(iprot); + struct.success.add(_elem922); } } struct.setSuccessIsSet(true); @@ -47841,14 +47841,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 2: // PRIMARY_KEYS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list916 = iprot.readListBegin(); - struct.primaryKeys = new ArrayList(_list916.size); - SQLPrimaryKey _elem917; - for (int _i918 = 0; _i918 < _list916.size; ++_i918) + org.apache.thrift.protocol.TList _list924 = iprot.readListBegin(); + struct.primaryKeys = new ArrayList(_list924.size); + SQLPrimaryKey _elem925; + for (int _i926 = 0; _i926 < _list924.size; ++_i926) { - _elem917 = new SQLPrimaryKey(); - _elem917.read(iprot); - struct.primaryKeys.add(_elem917); + _elem925 = new SQLPrimaryKey(); + _elem925.read(iprot); + struct.primaryKeys.add(_elem925); } iprot.readListEnd(); } @@ -47860,14 +47860,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 3: // FOREIGN_KEYS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list919 = iprot.readListBegin(); - struct.foreignKeys = new ArrayList(_list919.size); - SQLForeignKey _elem920; - for (int _i921 = 0; _i921 < _list919.size; ++_i921) + org.apache.thrift.protocol.TList _list927 = iprot.readListBegin(); + struct.foreignKeys = new ArrayList(_list927.size); + SQLForeignKey _elem928; + for (int _i929 = 0; _i929 < _list927.size; ++_i929) { - _elem920 = new SQLForeignKey(); - _elem920.read(iprot); - struct.foreignKeys.add(_elem920); + _elem928 = new SQLForeignKey(); + _elem928.read(iprot); + struct.foreignKeys.add(_elem928); } iprot.readListEnd(); } @@ -47879,14 +47879,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 4: // UNIQUE_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list922 = iprot.readListBegin(); - struct.uniqueConstraints = new ArrayList(_list922.size); - SQLUniqueConstraint _elem923; - for (int _i924 = 0; _i924 < _list922.size; ++_i924) + org.apache.thrift.protocol.TList _list930 = iprot.readListBegin(); + struct.uniqueConstraints = new ArrayList(_list930.size); + SQLUniqueConstraint _elem931; + for (int _i932 = 0; _i932 < _list930.size; ++_i932) { - _elem923 = new SQLUniqueConstraint(); - _elem923.read(iprot); - struct.uniqueConstraints.add(_elem923); + _elem931 = new SQLUniqueConstraint(); + _elem931.read(iprot); + struct.uniqueConstraints.add(_elem931); } iprot.readListEnd(); } @@ -47898,14 +47898,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 5: // NOT_NULL_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list925 = iprot.readListBegin(); - struct.notNullConstraints = new ArrayList(_list925.size); - SQLNotNullConstraint _elem926; - for (int _i927 = 0; _i927 < _list925.size; ++_i927) + org.apache.thrift.protocol.TList _list933 = iprot.readListBegin(); + struct.notNullConstraints = new ArrayList(_list933.size); + SQLNotNullConstraint _elem934; + for (int _i935 = 0; _i935 < _list933.size; ++_i935) { - _elem926 = new SQLNotNullConstraint(); - _elem926.read(iprot); - struct.notNullConstraints.add(_elem926); + _elem934 = new SQLNotNullConstraint(); + _elem934.read(iprot); + struct.notNullConstraints.add(_elem934); } iprot.readListEnd(); } @@ -47936,9 +47936,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(PRIMARY_KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.primaryKeys.size())); - for (SQLPrimaryKey _iter928 : struct.primaryKeys) + for (SQLPrimaryKey _iter936 : struct.primaryKeys) { - _iter928.write(oprot); + _iter936.write(oprot); } oprot.writeListEnd(); } @@ -47948,9 +47948,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(FOREIGN_KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.foreignKeys.size())); - for (SQLForeignKey _iter929 : struct.foreignKeys) + for (SQLForeignKey _iter937 : struct.foreignKeys) { - _iter929.write(oprot); + _iter937.write(oprot); } oprot.writeListEnd(); } @@ -47960,9 +47960,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(UNIQUE_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.uniqueConstraints.size())); - for (SQLUniqueConstraint _iter930 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter938 : struct.uniqueConstraints) { - _iter930.write(oprot); + _iter938.write(oprot); } oprot.writeListEnd(); } @@ -47972,9 +47972,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(NOT_NULL_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.notNullConstraints.size())); - for (SQLNotNullConstraint _iter931 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter939 : struct.notNullConstraints) { - _iter931.write(oprot); + _iter939.write(oprot); } oprot.writeListEnd(); } @@ -48020,36 +48020,36 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_table_with_c if (struct.isSetPrimaryKeys()) { { oprot.writeI32(struct.primaryKeys.size()); - for (SQLPrimaryKey _iter932 : struct.primaryKeys) + for (SQLPrimaryKey _iter940 : struct.primaryKeys) { - _iter932.write(oprot); + _iter940.write(oprot); } } } if (struct.isSetForeignKeys()) { { oprot.writeI32(struct.foreignKeys.size()); - for (SQLForeignKey _iter933 : struct.foreignKeys) + for (SQLForeignKey _iter941 : struct.foreignKeys) { - _iter933.write(oprot); + _iter941.write(oprot); } } } if (struct.isSetUniqueConstraints()) { { oprot.writeI32(struct.uniqueConstraints.size()); - for (SQLUniqueConstraint _iter934 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter942 : struct.uniqueConstraints) { - _iter934.write(oprot); + _iter942.write(oprot); } } } if (struct.isSetNotNullConstraints()) { { oprot.writeI32(struct.notNullConstraints.size()); - for (SQLNotNullConstraint _iter935 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter943 : struct.notNullConstraints) { - _iter935.write(oprot); + _iter943.write(oprot); } } } @@ -48066,56 +48066,56 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_table_with_co } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list936 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.primaryKeys = new ArrayList(_list936.size); - SQLPrimaryKey _elem937; - for (int _i938 = 0; _i938 < _list936.size; ++_i938) + org.apache.thrift.protocol.TList _list944 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.primaryKeys = new ArrayList(_list944.size); + SQLPrimaryKey _elem945; + for (int _i946 = 0; _i946 < _list944.size; ++_i946) { - _elem937 = new SQLPrimaryKey(); - _elem937.read(iprot); - struct.primaryKeys.add(_elem937); + _elem945 = new SQLPrimaryKey(); + _elem945.read(iprot); + struct.primaryKeys.add(_elem945); } } struct.setPrimaryKeysIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list939 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.foreignKeys = new ArrayList(_list939.size); - SQLForeignKey _elem940; - for (int _i941 = 0; _i941 < _list939.size; ++_i941) + org.apache.thrift.protocol.TList _list947 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.foreignKeys = new ArrayList(_list947.size); + SQLForeignKey _elem948; + for (int _i949 = 0; _i949 < _list947.size; ++_i949) { - _elem940 = new SQLForeignKey(); - _elem940.read(iprot); - struct.foreignKeys.add(_elem940); + _elem948 = new SQLForeignKey(); + _elem948.read(iprot); + struct.foreignKeys.add(_elem948); } } struct.setForeignKeysIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list942 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.uniqueConstraints = new ArrayList(_list942.size); - SQLUniqueConstraint _elem943; - for (int _i944 = 0; _i944 < _list942.size; ++_i944) + org.apache.thrift.protocol.TList _list950 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.uniqueConstraints = new ArrayList(_list950.size); + SQLUniqueConstraint _elem951; + for (int _i952 = 0; _i952 < _list950.size; ++_i952) { - _elem943 = new SQLUniqueConstraint(); - _elem943.read(iprot); - struct.uniqueConstraints.add(_elem943); + _elem951 = new SQLUniqueConstraint(); + _elem951.read(iprot); + struct.uniqueConstraints.add(_elem951); } } struct.setUniqueConstraintsIsSet(true); } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list945 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.notNullConstraints = new ArrayList(_list945.size); - SQLNotNullConstraint _elem946; - for (int _i947 = 0; _i947 < _list945.size; ++_i947) + org.apache.thrift.protocol.TList _list953 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.notNullConstraints = new ArrayList(_list953.size); + SQLNotNullConstraint _elem954; + for (int _i955 = 0; _i955 < _list953.size; ++_i955) { - _elem946 = new SQLNotNullConstraint(); - _elem946.read(iprot); - struct.notNullConstraints.add(_elem946); + _elem954 = new SQLNotNullConstraint(); + _elem954.read(iprot); + struct.notNullConstraints.add(_elem954); } } struct.setNotNullConstraintsIsSet(true); @@ -55607,13 +55607,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, truncate_table_args case 3: // PART_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list948 = iprot.readListBegin(); - struct.partNames = new ArrayList(_list948.size); - String _elem949; - for (int _i950 = 0; _i950 < _list948.size; ++_i950) + org.apache.thrift.protocol.TList _list956 = iprot.readListBegin(); + struct.partNames = new ArrayList(_list956.size); + String _elem957; + for (int _i958 = 0; _i958 < _list956.size; ++_i958) { - _elem949 = iprot.readString(); - struct.partNames.add(_elem949); + _elem957 = iprot.readString(); + struct.partNames.add(_elem957); } iprot.readListEnd(); } @@ -55649,9 +55649,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, truncate_table_arg oprot.writeFieldBegin(PART_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partNames.size())); - for (String _iter951 : struct.partNames) + for (String _iter959 : struct.partNames) { - oprot.writeString(_iter951); + oprot.writeString(_iter959); } oprot.writeListEnd(); } @@ -55694,9 +55694,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, truncate_table_args if (struct.isSetPartNames()) { { oprot.writeI32(struct.partNames.size()); - for (String _iter952 : struct.partNames) + for (String _iter960 : struct.partNames) { - oprot.writeString(_iter952); + oprot.writeString(_iter960); } } } @@ -55716,13 +55716,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, truncate_table_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list953 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partNames = new ArrayList(_list953.size); - String _elem954; - for (int _i955 = 0; _i955 < _list953.size; ++_i955) + org.apache.thrift.protocol.TList _list961 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partNames = new ArrayList(_list961.size); + String _elem962; + for (int _i963 = 0; _i963 < _list961.size; ++_i963) { - _elem954 = iprot.readString(); - struct.partNames.add(_elem954); + _elem962 = iprot.readString(); + struct.partNames.add(_elem962); } } struct.setPartNamesIsSet(true); @@ -56947,13 +56947,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list956 = iprot.readListBegin(); - struct.success = new ArrayList(_list956.size); - String _elem957; - for (int _i958 = 0; _i958 < _list956.size; ++_i958) + org.apache.thrift.protocol.TList _list964 = iprot.readListBegin(); + struct.success = new ArrayList(_list964.size); + String _elem965; + for (int _i966 = 0; _i966 < _list964.size; ++_i966) { - _elem957 = iprot.readString(); - struct.success.add(_elem957); + _elem965 = iprot.readString(); + struct.success.add(_elem965); } iprot.readListEnd(); } @@ -56988,9 +56988,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter959 : struct.success) + for (String _iter967 : struct.success) { - oprot.writeString(_iter959); + oprot.writeString(_iter967); } oprot.writeListEnd(); } @@ -57029,9 +57029,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter960 : struct.success) + for (String _iter968 : struct.success) { - oprot.writeString(_iter960); + oprot.writeString(_iter968); } } } @@ -57046,13 +57046,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list961 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list961.size); - String _elem962; - for (int _i963 = 0; _i963 < _list961.size; ++_i963) + org.apache.thrift.protocol.TList _list969 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list969.size); + String _elem970; + for (int _i971 = 0; _i971 < _list969.size; ++_i971) { - _elem962 = iprot.readString(); - struct.success.add(_elem962); + _elem970 = iprot.readString(); + struct.success.add(_elem970); } } struct.setSuccessIsSet(true); @@ -58026,13 +58026,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_by_type_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list964 = iprot.readListBegin(); - struct.success = new ArrayList(_list964.size); - String _elem965; - for (int _i966 = 0; _i966 < _list964.size; ++_i966) + org.apache.thrift.protocol.TList _list972 = iprot.readListBegin(); + struct.success = new ArrayList(_list972.size); + String _elem973; + for (int _i974 = 0; _i974 < _list972.size; ++_i974) { - _elem965 = iprot.readString(); - struct.success.add(_elem965); + _elem973 = iprot.readString(); + struct.success.add(_elem973); } iprot.readListEnd(); } @@ -58067,9 +58067,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_by_type oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter967 : struct.success) + for (String _iter975 : struct.success) { - oprot.writeString(_iter967); + oprot.writeString(_iter975); } oprot.writeListEnd(); } @@ -58108,9 +58108,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter968 : struct.success) + for (String _iter976 : struct.success) { - oprot.writeString(_iter968); + oprot.writeString(_iter976); } } } @@ -58125,13 +58125,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_r BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list969 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list969.size); - String _elem970; - for (int _i971 = 0; _i971 < _list969.size; ++_i971) + org.apache.thrift.protocol.TList _list977 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list977.size); + String _elem978; + for (int _i979 = 0; _i979 < _list977.size; ++_i979) { - _elem970 = iprot.readString(); - struct.success.add(_elem970); + _elem978 = iprot.readString(); + struct.success.add(_elem978); } } struct.setSuccessIsSet(true); @@ -58897,13 +58897,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_materialized_vi case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list972 = iprot.readListBegin(); - struct.success = new ArrayList(_list972.size); - String _elem973; - for (int _i974 = 0; _i974 < _list972.size; ++_i974) + org.apache.thrift.protocol.TList _list980 = iprot.readListBegin(); + struct.success = new ArrayList(_list980.size); + String _elem981; + for (int _i982 = 0; _i982 < _list980.size; ++_i982) { - _elem973 = iprot.readString(); - struct.success.add(_elem973); + _elem981 = iprot.readString(); + struct.success.add(_elem981); } iprot.readListEnd(); } @@ -58938,9 +58938,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_materialized_v oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter975 : struct.success) + for (String _iter983 : struct.success) { - oprot.writeString(_iter975); + oprot.writeString(_iter983); } oprot.writeListEnd(); } @@ -58979,9 +58979,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_materialized_vi if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter976 : struct.success) + for (String _iter984 : struct.success) { - oprot.writeString(_iter976); + oprot.writeString(_iter984); } } } @@ -58996,13 +58996,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_materialized_vie BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list977 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list977.size); - String _elem978; - for (int _i979 = 0; _i979 < _list977.size; ++_i979) + org.apache.thrift.protocol.TList _list985 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list985.size); + String _elem986; + for (int _i987 = 0; _i987 < _list985.size; ++_i987) { - _elem978 = iprot.readString(); - struct.success.add(_elem978); + _elem986 = iprot.readString(); + struct.success.add(_elem986); } } struct.setSuccessIsSet(true); @@ -59507,13 +59507,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_args case 3: // TBL_TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list980 = iprot.readListBegin(); - struct.tbl_types = new ArrayList(_list980.size); - String _elem981; - for (int _i982 = 0; _i982 < _list980.size; ++_i982) + org.apache.thrift.protocol.TList _list988 = iprot.readListBegin(); + struct.tbl_types = new ArrayList(_list988.size); + String _elem989; + for (int _i990 = 0; _i990 < _list988.size; ++_i990) { - _elem981 = iprot.readString(); - struct.tbl_types.add(_elem981); + _elem989 = iprot.readString(); + struct.tbl_types.add(_elem989); } iprot.readListEnd(); } @@ -59549,9 +59549,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_arg oprot.writeFieldBegin(TBL_TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_types.size())); - for (String _iter983 : struct.tbl_types) + for (String _iter991 : struct.tbl_types) { - oprot.writeString(_iter983); + oprot.writeString(_iter991); } oprot.writeListEnd(); } @@ -59594,9 +59594,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args if (struct.isSetTbl_types()) { { oprot.writeI32(struct.tbl_types.size()); - for (String _iter984 : struct.tbl_types) + for (String _iter992 : struct.tbl_types) { - oprot.writeString(_iter984); + oprot.writeString(_iter992); } } } @@ -59616,13 +59616,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list985 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_types = new ArrayList(_list985.size); - String _elem986; - for (int _i987 = 0; _i987 < _list985.size; ++_i987) + org.apache.thrift.protocol.TList _list993 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_types = new ArrayList(_list993.size); + String _elem994; + for (int _i995 = 0; _i995 < _list993.size; ++_i995) { - _elem986 = iprot.readString(); - struct.tbl_types.add(_elem986); + _elem994 = iprot.readString(); + struct.tbl_types.add(_elem994); } } struct.setTbl_typesIsSet(true); @@ -60028,14 +60028,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list988 = iprot.readListBegin(); - struct.success = new ArrayList(_list988.size); - TableMeta _elem989; - for (int _i990 = 0; _i990 < _list988.size; ++_i990) + org.apache.thrift.protocol.TList _list996 = iprot.readListBegin(); + struct.success = new ArrayList(_list996.size); + TableMeta _elem997; + for (int _i998 = 0; _i998 < _list996.size; ++_i998) { - _elem989 = new TableMeta(); - _elem989.read(iprot); - struct.success.add(_elem989); + _elem997 = new TableMeta(); + _elem997.read(iprot); + struct.success.add(_elem997); } iprot.readListEnd(); } @@ -60070,9 +60070,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TableMeta _iter991 : struct.success) + for (TableMeta _iter999 : struct.success) { - _iter991.write(oprot); + _iter999.write(oprot); } oprot.writeListEnd(); } @@ -60111,9 +60111,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TableMeta _iter992 : struct.success) + for (TableMeta _iter1000 : struct.success) { - _iter992.write(oprot); + _iter1000.write(oprot); } } } @@ -60128,14 +60128,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list993 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list993.size); - TableMeta _elem994; - for (int _i995 = 0; _i995 < _list993.size; ++_i995) + org.apache.thrift.protocol.TList _list1001 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1001.size); + TableMeta _elem1002; + for (int _i1003 = 0; _i1003 < _list1001.size; ++_i1003) { - _elem994 = new TableMeta(); - _elem994.read(iprot); - struct.success.add(_elem994); + _elem1002 = new TableMeta(); + _elem1002.read(iprot); + struct.success.add(_elem1002); } } struct.setSuccessIsSet(true); @@ -60901,13 +60901,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_tables_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list996 = iprot.readListBegin(); - struct.success = new ArrayList(_list996.size); - String _elem997; - for (int _i998 = 0; _i998 < _list996.size; ++_i998) + org.apache.thrift.protocol.TList _list1004 = iprot.readListBegin(); + struct.success = new ArrayList(_list1004.size); + String _elem1005; + for (int _i1006 = 0; _i1006 < _list1004.size; ++_i1006) { - _elem997 = iprot.readString(); - struct.success.add(_elem997); + _elem1005 = iprot.readString(); + struct.success.add(_elem1005); } iprot.readListEnd(); } @@ -60942,9 +60942,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_tables_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter999 : struct.success) + for (String _iter1007 : struct.success) { - oprot.writeString(_iter999); + oprot.writeString(_iter1007); } oprot.writeListEnd(); } @@ -60983,9 +60983,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1000 : struct.success) + for (String _iter1008 : struct.success) { - oprot.writeString(_iter1000); + oprot.writeString(_iter1008); } } } @@ -61000,13 +61000,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1001 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1001.size); - String _elem1002; - for (int _i1003 = 0; _i1003 < _list1001.size; ++_i1003) + org.apache.thrift.protocol.TList _list1009 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1009.size); + String _elem1010; + for (int _i1011 = 0; _i1011 < _list1009.size; ++_i1011) { - _elem1002 = iprot.readString(); - struct.success.add(_elem1002); + _elem1010 = iprot.readString(); + struct.success.add(_elem1010); } } struct.setSuccessIsSet(true); @@ -62459,13 +62459,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 2: // TBL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1004 = iprot.readListBegin(); - struct.tbl_names = new ArrayList(_list1004.size); - String _elem1005; - for (int _i1006 = 0; _i1006 < _list1004.size; ++_i1006) + org.apache.thrift.protocol.TList _list1012 = iprot.readListBegin(); + struct.tbl_names = new ArrayList(_list1012.size); + String _elem1013; + for (int _i1014 = 0; _i1014 < _list1012.size; ++_i1014) { - _elem1005 = iprot.readString(); - struct.tbl_names.add(_elem1005); + _elem1013 = iprot.readString(); + struct.tbl_names.add(_elem1013); } iprot.readListEnd(); } @@ -62496,9 +62496,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_names.size())); - for (String _iter1007 : struct.tbl_names) + for (String _iter1015 : struct.tbl_names) { - oprot.writeString(_iter1007); + oprot.writeString(_iter1015); } oprot.writeListEnd(); } @@ -62535,9 +62535,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetTbl_names()) { { oprot.writeI32(struct.tbl_names.size()); - for (String _iter1008 : struct.tbl_names) + for (String _iter1016 : struct.tbl_names) { - oprot.writeString(_iter1008); + oprot.writeString(_iter1016); } } } @@ -62553,13 +62553,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1009 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_names = new ArrayList(_list1009.size); - String _elem1010; - for (int _i1011 = 0; _i1011 < _list1009.size; ++_i1011) + org.apache.thrift.protocol.TList _list1017 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_names = new ArrayList(_list1017.size); + String _elem1018; + for (int _i1019 = 0; _i1019 < _list1017.size; ++_i1019) { - _elem1010 = iprot.readString(); - struct.tbl_names.add(_elem1010); + _elem1018 = iprot.readString(); + struct.tbl_names.add(_elem1018); } } struct.setTbl_namesIsSet(true); @@ -62884,14 +62884,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1012 = iprot.readListBegin(); - struct.success = new ArrayList
(_list1012.size); - Table _elem1013; - for (int _i1014 = 0; _i1014 < _list1012.size; ++_i1014) + org.apache.thrift.protocol.TList _list1020 = iprot.readListBegin(); + struct.success = new ArrayList
(_list1020.size); + Table _elem1021; + for (int _i1022 = 0; _i1022 < _list1020.size; ++_i1022) { - _elem1013 = new Table(); - _elem1013.read(iprot); - struct.success.add(_elem1013); + _elem1021 = new Table(); + _elem1021.read(iprot); + struct.success.add(_elem1021); } iprot.readListEnd(); } @@ -62917,9 +62917,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Table _iter1015 : struct.success) + for (Table _iter1023 : struct.success) { - _iter1015.write(oprot); + _iter1023.write(oprot); } oprot.writeListEnd(); } @@ -62950,9 +62950,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Table _iter1016 : struct.success) + for (Table _iter1024 : struct.success) { - _iter1016.write(oprot); + _iter1024.write(oprot); } } } @@ -62964,14 +62964,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1017 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList
(_list1017.size); - Table _elem1018; - for (int _i1019 = 0; _i1019 < _list1017.size; ++_i1019) + org.apache.thrift.protocol.TList _list1025 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList
(_list1025.size); + Table _elem1026; + for (int _i1027 = 0; _i1027 < _list1025.size; ++_i1027) { - _elem1018 = new Table(); - _elem1018.read(iprot); - struct.success.add(_elem1018); + _elem1026 = new Table(); + _elem1026.read(iprot); + struct.success.add(_elem1026); } } struct.setSuccessIsSet(true); @@ -65364,13 +65364,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_materialization case 2: // TBL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1020 = iprot.readListBegin(); - struct.tbl_names = new ArrayList(_list1020.size); - String _elem1021; - for (int _i1022 = 0; _i1022 < _list1020.size; ++_i1022) + org.apache.thrift.protocol.TList _list1028 = iprot.readListBegin(); + struct.tbl_names = new ArrayList(_list1028.size); + String _elem1029; + for (int _i1030 = 0; _i1030 < _list1028.size; ++_i1030) { - _elem1021 = iprot.readString(); - struct.tbl_names.add(_elem1021); + _elem1029 = iprot.readString(); + struct.tbl_names.add(_elem1029); } iprot.readListEnd(); } @@ -65401,9 +65401,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_materializatio oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_names.size())); - for (String _iter1023 : struct.tbl_names) + for (String _iter1031 : struct.tbl_names) { - oprot.writeString(_iter1023); + oprot.writeString(_iter1031); } oprot.writeListEnd(); } @@ -65440,9 +65440,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_materialization if (struct.isSetTbl_names()) { { oprot.writeI32(struct.tbl_names.size()); - for (String _iter1024 : struct.tbl_names) + for (String _iter1032 : struct.tbl_names) { - oprot.writeString(_iter1024); + oprot.writeString(_iter1032); } } } @@ -65458,13 +65458,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_materialization_ } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1025 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_names = new ArrayList(_list1025.size); - String _elem1026; - for (int _i1027 = 0; _i1027 < _list1025.size; ++_i1027) + org.apache.thrift.protocol.TList _list1033 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_names = new ArrayList(_list1033.size); + String _elem1034; + for (int _i1035 = 0; _i1035 < _list1033.size; ++_i1035) { - _elem1026 = iprot.readString(); - struct.tbl_names.add(_elem1026); + _elem1034 = iprot.readString(); + struct.tbl_names.add(_elem1034); } } struct.setTbl_namesIsSet(true); @@ -66037,16 +66037,16 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_materialization case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1028 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map1028.size); - String _key1029; - Materialization _val1030; - for (int _i1031 = 0; _i1031 < _map1028.size; ++_i1031) + org.apache.thrift.protocol.TMap _map1036 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map1036.size); + String _key1037; + Materialization _val1038; + for (int _i1039 = 0; _i1039 < _map1036.size; ++_i1039) { - _key1029 = iprot.readString(); - _val1030 = new Materialization(); - _val1030.read(iprot); - struct.success.put(_key1029, _val1030); + _key1037 = iprot.readString(); + _val1038 = new Materialization(); + _val1038.read(iprot); + struct.success.put(_key1037, _val1038); } iprot.readMapEnd(); } @@ -66099,10 +66099,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_materializatio oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Map.Entry _iter1032 : struct.success.entrySet()) + for (Map.Entry _iter1040 : struct.success.entrySet()) { - oprot.writeString(_iter1032.getKey()); - _iter1032.getValue().write(oprot); + oprot.writeString(_iter1040.getKey()); + _iter1040.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -66157,10 +66157,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_materialization if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter1033 : struct.success.entrySet()) + for (Map.Entry _iter1041 : struct.success.entrySet()) { - oprot.writeString(_iter1033.getKey()); - _iter1033.getValue().write(oprot); + oprot.writeString(_iter1041.getKey()); + _iter1041.getValue().write(oprot); } } } @@ -66181,16 +66181,16 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_materialization_ BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1034 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap(2*_map1034.size); - String _key1035; - Materialization _val1036; - for (int _i1037 = 0; _i1037 < _map1034.size; ++_i1037) + org.apache.thrift.protocol.TMap _map1042 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap(2*_map1042.size); + String _key1043; + Materialization _val1044; + for (int _i1045 = 0; _i1045 < _map1042.size; ++_i1045) { - _key1035 = iprot.readString(); - _val1036 = new Materialization(); - _val1036.read(iprot); - struct.success.put(_key1035, _val1036); + _key1043 = iprot.readString(); + _val1044 = new Materialization(); + _val1044.read(iprot); + struct.success.put(_key1043, _val1044); } } struct.setSuccessIsSet(true); @@ -68479,13 +68479,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_names_by_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1038 = iprot.readListBegin(); - struct.success = new ArrayList(_list1038.size); - String _elem1039; - for (int _i1040 = 0; _i1040 < _list1038.size; ++_i1040) + org.apache.thrift.protocol.TList _list1046 = iprot.readListBegin(); + struct.success = new ArrayList(_list1046.size); + String _elem1047; + for (int _i1048 = 0; _i1048 < _list1046.size; ++_i1048) { - _elem1039 = iprot.readString(); - struct.success.add(_elem1039); + _elem1047 = iprot.readString(); + struct.success.add(_elem1047); } iprot.readListEnd(); } @@ -68538,9 +68538,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_names_by oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1041 : struct.success) + for (String _iter1049 : struct.success) { - oprot.writeString(_iter1041); + oprot.writeString(_iter1049); } oprot.writeListEnd(); } @@ -68595,9 +68595,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1042 : struct.success) + for (String _iter1050 : struct.success) { - oprot.writeString(_iter1042); + oprot.writeString(_iter1050); } } } @@ -68618,13 +68618,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_f BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1043 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1043.size); - String _elem1044; - for (int _i1045 = 0; _i1045 < _list1043.size; ++_i1045) + org.apache.thrift.protocol.TList _list1051 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1051.size); + String _elem1052; + for (int _i1053 = 0; _i1053 < _list1051.size; ++_i1053) { - _elem1044 = iprot.readString(); - struct.success.add(_elem1044); + _elem1052 = iprot.readString(); + struct.success.add(_elem1052); } } struct.setSuccessIsSet(true); @@ -74483,14 +74483,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_args case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1046 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1046.size); - Partition _elem1047; - for (int _i1048 = 0; _i1048 < _list1046.size; ++_i1048) + org.apache.thrift.protocol.TList _list1054 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1054.size); + Partition _elem1055; + for (int _i1056 = 0; _i1056 < _list1054.size; ++_i1056) { - _elem1047 = new Partition(); - _elem1047.read(iprot); - struct.new_parts.add(_elem1047); + _elem1055 = new Partition(); + _elem1055.read(iprot); + struct.new_parts.add(_elem1055); } iprot.readListEnd(); } @@ -74516,9 +74516,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_arg oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1049 : struct.new_parts) + for (Partition _iter1057 : struct.new_parts) { - _iter1049.write(oprot); + _iter1057.write(oprot); } oprot.writeListEnd(); } @@ -74549,9 +74549,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_args if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1050 : struct.new_parts) + for (Partition _iter1058 : struct.new_parts) { - _iter1050.write(oprot); + _iter1058.write(oprot); } } } @@ -74563,14 +74563,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_args BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1051 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1051.size); - Partition _elem1052; - for (int _i1053 = 0; _i1053 < _list1051.size; ++_i1053) + org.apache.thrift.protocol.TList _list1059 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1059.size); + Partition _elem1060; + for (int _i1061 = 0; _i1061 < _list1059.size; ++_i1061) { - _elem1052 = new Partition(); - _elem1052.read(iprot); - struct.new_parts.add(_elem1052); + _elem1060 = new Partition(); + _elem1060.read(iprot); + struct.new_parts.add(_elem1060); } } struct.setNew_partsIsSet(true); @@ -75571,14 +75571,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_pspe case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1054 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1054.size); - PartitionSpec _elem1055; - for (int _i1056 = 0; _i1056 < _list1054.size; ++_i1056) + org.apache.thrift.protocol.TList _list1062 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1062.size); + PartitionSpec _elem1063; + for (int _i1064 = 0; _i1064 < _list1062.size; ++_i1064) { - _elem1055 = new PartitionSpec(); - _elem1055.read(iprot); - struct.new_parts.add(_elem1055); + _elem1063 = new PartitionSpec(); + _elem1063.read(iprot); + struct.new_parts.add(_elem1063); } iprot.readListEnd(); } @@ -75604,9 +75604,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_psp oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (PartitionSpec _iter1057 : struct.new_parts) + for (PartitionSpec _iter1065 : struct.new_parts) { - _iter1057.write(oprot); + _iter1065.write(oprot); } oprot.writeListEnd(); } @@ -75637,9 +75637,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspe if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (PartitionSpec _iter1058 : struct.new_parts) + for (PartitionSpec _iter1066 : struct.new_parts) { - _iter1058.write(oprot); + _iter1066.write(oprot); } } } @@ -75651,14 +75651,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspec BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1059 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1059.size); - PartitionSpec _elem1060; - for (int _i1061 = 0; _i1061 < _list1059.size; ++_i1061) + org.apache.thrift.protocol.TList _list1067 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1067.size); + PartitionSpec _elem1068; + for (int _i1069 = 0; _i1069 < _list1067.size; ++_i1069) { - _elem1060 = new PartitionSpec(); - _elem1060.read(iprot); - struct.new_parts.add(_elem1060); + _elem1068 = new PartitionSpec(); + _elem1068.read(iprot); + struct.new_parts.add(_elem1068); } } struct.setNew_partsIsSet(true); @@ -76834,13 +76834,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1062 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1062.size); - String _elem1063; - for (int _i1064 = 0; _i1064 < _list1062.size; ++_i1064) + org.apache.thrift.protocol.TList _list1070 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1070.size); + String _elem1071; + for (int _i1072 = 0; _i1072 < _list1070.size; ++_i1072) { - _elem1063 = iprot.readString(); - struct.part_vals.add(_elem1063); + _elem1071 = iprot.readString(); + struct.part_vals.add(_elem1071); } iprot.readListEnd(); } @@ -76876,9 +76876,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1065 : struct.part_vals) + for (String _iter1073 : struct.part_vals) { - oprot.writeString(_iter1065); + oprot.writeString(_iter1073); } oprot.writeListEnd(); } @@ -76921,9 +76921,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1066 : struct.part_vals) + for (String _iter1074 : struct.part_vals) { - oprot.writeString(_iter1066); + oprot.writeString(_iter1074); } } } @@ -76943,13 +76943,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1067 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1067.size); - String _elem1068; - for (int _i1069 = 0; _i1069 < _list1067.size; ++_i1069) + org.apache.thrift.protocol.TList _list1075 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1075.size); + String _elem1076; + for (int _i1077 = 0; _i1077 < _list1075.size; ++_i1077) { - _elem1068 = iprot.readString(); - struct.part_vals.add(_elem1068); + _elem1076 = iprot.readString(); + struct.part_vals.add(_elem1076); } } struct.setPart_valsIsSet(true); @@ -79258,13 +79258,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_wi case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1070 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1070.size); - String _elem1071; - for (int _i1072 = 0; _i1072 < _list1070.size; ++_i1072) + org.apache.thrift.protocol.TList _list1078 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1078.size); + String _elem1079; + for (int _i1080 = 0; _i1080 < _list1078.size; ++_i1080) { - _elem1071 = iprot.readString(); - struct.part_vals.add(_elem1071); + _elem1079 = iprot.readString(); + struct.part_vals.add(_elem1079); } iprot.readListEnd(); } @@ -79309,9 +79309,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_w oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1073 : struct.part_vals) + for (String _iter1081 : struct.part_vals) { - oprot.writeString(_iter1073); + oprot.writeString(_iter1081); } oprot.writeListEnd(); } @@ -79362,9 +79362,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_wi if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1074 : struct.part_vals) + for (String _iter1082 : struct.part_vals) { - oprot.writeString(_iter1074); + oprot.writeString(_iter1082); } } } @@ -79387,13 +79387,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1075 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1075.size); - String _elem1076; - for (int _i1077 = 0; _i1077 < _list1075.size; ++_i1077) + org.apache.thrift.protocol.TList _list1083 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1083.size); + String _elem1084; + for (int _i1085 = 0; _i1085 < _list1083.size; ++_i1085) { - _elem1076 = iprot.readString(); - struct.part_vals.add(_elem1076); + _elem1084 = iprot.readString(); + struct.part_vals.add(_elem1084); } } struct.setPart_valsIsSet(true); @@ -83263,13 +83263,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1078 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1078.size); - String _elem1079; - for (int _i1080 = 0; _i1080 < _list1078.size; ++_i1080) + org.apache.thrift.protocol.TList _list1086 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1086.size); + String _elem1087; + for (int _i1088 = 0; _i1088 < _list1086.size; ++_i1088) { - _elem1079 = iprot.readString(); - struct.part_vals.add(_elem1079); + _elem1087 = iprot.readString(); + struct.part_vals.add(_elem1087); } iprot.readListEnd(); } @@ -83313,9 +83313,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_arg oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1081 : struct.part_vals) + for (String _iter1089 : struct.part_vals) { - oprot.writeString(_iter1081); + oprot.writeString(_iter1089); } oprot.writeListEnd(); } @@ -83364,9 +83364,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1082 : struct.part_vals) + for (String _iter1090 : struct.part_vals) { - oprot.writeString(_iter1082); + oprot.writeString(_iter1090); } } } @@ -83389,13 +83389,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1083 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1083.size); - String _elem1084; - for (int _i1085 = 0; _i1085 < _list1083.size; ++_i1085) + org.apache.thrift.protocol.TList _list1091 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1091.size); + String _elem1092; + for (int _i1093 = 0; _i1093 < _list1091.size; ++_i1093) { - _elem1084 = iprot.readString(); - struct.part_vals.add(_elem1084); + _elem1092 = iprot.readString(); + struct.part_vals.add(_elem1092); } } struct.setPart_valsIsSet(true); @@ -84634,13 +84634,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1086 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1086.size); - String _elem1087; - for (int _i1088 = 0; _i1088 < _list1086.size; ++_i1088) + org.apache.thrift.protocol.TList _list1094 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1094.size); + String _elem1095; + for (int _i1096 = 0; _i1096 < _list1094.size; ++_i1096) { - _elem1087 = iprot.readString(); - struct.part_vals.add(_elem1087); + _elem1095 = iprot.readString(); + struct.part_vals.add(_elem1095); } iprot.readListEnd(); } @@ -84693,9 +84693,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1089 : struct.part_vals) + for (String _iter1097 : struct.part_vals) { - oprot.writeString(_iter1089); + oprot.writeString(_iter1097); } oprot.writeListEnd(); } @@ -84752,9 +84752,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1090 : struct.part_vals) + for (String _iter1098 : struct.part_vals) { - oprot.writeString(_iter1090); + oprot.writeString(_iter1098); } } } @@ -84780,13 +84780,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1091 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1091.size); - String _elem1092; - for (int _i1093 = 0; _i1093 < _list1091.size; ++_i1093) + org.apache.thrift.protocol.TList _list1099 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1099.size); + String _elem1100; + for (int _i1101 = 0; _i1101 < _list1099.size; ++_i1101) { - _elem1092 = iprot.readString(); - struct.part_vals.add(_elem1092); + _elem1100 = iprot.readString(); + struct.part_vals.add(_elem1100); } } struct.setPart_valsIsSet(true); @@ -89388,13 +89388,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1094 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1094.size); - String _elem1095; - for (int _i1096 = 0; _i1096 < _list1094.size; ++_i1096) + org.apache.thrift.protocol.TList _list1102 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1102.size); + String _elem1103; + for (int _i1104 = 0; _i1104 < _list1102.size; ++_i1104) { - _elem1095 = iprot.readString(); - struct.part_vals.add(_elem1095); + _elem1103 = iprot.readString(); + struct.part_vals.add(_elem1103); } iprot.readListEnd(); } @@ -89430,9 +89430,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_args oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1097 : struct.part_vals) + for (String _iter1105 : struct.part_vals) { - oprot.writeString(_iter1097); + oprot.writeString(_iter1105); } oprot.writeListEnd(); } @@ -89475,9 +89475,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1098 : struct.part_vals) + for (String _iter1106 : struct.part_vals) { - oprot.writeString(_iter1098); + oprot.writeString(_iter1106); } } } @@ -89497,13 +89497,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_args s } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1099 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1099.size); - String _elem1100; - for (int _i1101 = 0; _i1101 < _list1099.size; ++_i1101) + org.apache.thrift.protocol.TList _list1107 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1107.size); + String _elem1108; + for (int _i1109 = 0; _i1109 < _list1107.size; ++_i1109) { - _elem1100 = iprot.readString(); - struct.part_vals.add(_elem1100); + _elem1108 = iprot.readString(); + struct.part_vals.add(_elem1108); } } struct.setPart_valsIsSet(true); @@ -90721,15 +90721,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1102 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map1102.size); - String _key1103; - String _val1104; - for (int _i1105 = 0; _i1105 < _map1102.size; ++_i1105) + org.apache.thrift.protocol.TMap _map1110 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map1110.size); + String _key1111; + String _val1112; + for (int _i1113 = 0; _i1113 < _map1110.size; ++_i1113) { - _key1103 = iprot.readString(); - _val1104 = iprot.readString(); - struct.partitionSpecs.put(_key1103, _val1104); + _key1111 = iprot.readString(); + _val1112 = iprot.readString(); + struct.partitionSpecs.put(_key1111, _val1112); } iprot.readMapEnd(); } @@ -90787,10 +90787,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter1106 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter1114 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1106.getKey()); - oprot.writeString(_iter1106.getValue()); + oprot.writeString(_iter1114.getKey()); + oprot.writeString(_iter1114.getValue()); } oprot.writeMapEnd(); } @@ -90853,10 +90853,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter1107 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter1115 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1107.getKey()); - oprot.writeString(_iter1107.getValue()); + oprot.writeString(_iter1115.getKey()); + oprot.writeString(_iter1115.getValue()); } } } @@ -90880,15 +90880,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1108 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map1108.size); - String _key1109; - String _val1110; - for (int _i1111 = 0; _i1111 < _map1108.size; ++_i1111) + org.apache.thrift.protocol.TMap _map1116 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map1116.size); + String _key1117; + String _val1118; + for (int _i1119 = 0; _i1119 < _map1116.size; ++_i1119) { - _key1109 = iprot.readString(); - _val1110 = iprot.readString(); - struct.partitionSpecs.put(_key1109, _val1110); + _key1117 = iprot.readString(); + _val1118 = iprot.readString(); + struct.partitionSpecs.put(_key1117, _val1118); } } struct.setPartitionSpecsIsSet(true); @@ -92334,15 +92334,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1112 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map1112.size); - String _key1113; - String _val1114; - for (int _i1115 = 0; _i1115 < _map1112.size; ++_i1115) + org.apache.thrift.protocol.TMap _map1120 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map1120.size); + String _key1121; + String _val1122; + for (int _i1123 = 0; _i1123 < _map1120.size; ++_i1123) { - _key1113 = iprot.readString(); - _val1114 = iprot.readString(); - struct.partitionSpecs.put(_key1113, _val1114); + _key1121 = iprot.readString(); + _val1122 = iprot.readString(); + struct.partitionSpecs.put(_key1121, _val1122); } iprot.readMapEnd(); } @@ -92400,10 +92400,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter1116 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter1124 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1116.getKey()); - oprot.writeString(_iter1116.getValue()); + oprot.writeString(_iter1124.getKey()); + oprot.writeString(_iter1124.getValue()); } oprot.writeMapEnd(); } @@ -92466,10 +92466,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter1117 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter1125 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1117.getKey()); - oprot.writeString(_iter1117.getValue()); + oprot.writeString(_iter1125.getKey()); + oprot.writeString(_iter1125.getValue()); } } } @@ -92493,15 +92493,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1118 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map1118.size); - String _key1119; - String _val1120; - for (int _i1121 = 0; _i1121 < _map1118.size; ++_i1121) + org.apache.thrift.protocol.TMap _map1126 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map1126.size); + String _key1127; + String _val1128; + for (int _i1129 = 0; _i1129 < _map1126.size; ++_i1129) { - _key1119 = iprot.readString(); - _val1120 = iprot.readString(); - struct.partitionSpecs.put(_key1119, _val1120); + _key1127 = iprot.readString(); + _val1128 = iprot.readString(); + struct.partitionSpecs.put(_key1127, _val1128); } } struct.setPartitionSpecsIsSet(true); @@ -93166,14 +93166,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1122 = iprot.readListBegin(); - struct.success = new ArrayList(_list1122.size); - Partition _elem1123; - for (int _i1124 = 0; _i1124 < _list1122.size; ++_i1124) + org.apache.thrift.protocol.TList _list1130 = iprot.readListBegin(); + struct.success = new ArrayList(_list1130.size); + Partition _elem1131; + for (int _i1132 = 0; _i1132 < _list1130.size; ++_i1132) { - _elem1123 = new Partition(); - _elem1123.read(iprot); - struct.success.add(_elem1123); + _elem1131 = new Partition(); + _elem1131.read(iprot); + struct.success.add(_elem1131); } iprot.readListEnd(); } @@ -93235,9 +93235,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1125 : struct.success) + for (Partition _iter1133 : struct.success) { - _iter1125.write(oprot); + _iter1133.write(oprot); } oprot.writeListEnd(); } @@ -93300,9 +93300,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1126 : struct.success) + for (Partition _iter1134 : struct.success) { - _iter1126.write(oprot); + _iter1134.write(oprot); } } } @@ -93326,14 +93326,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1127 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1127.size); - Partition _elem1128; - for (int _i1129 = 0; _i1129 < _list1127.size; ++_i1129) + org.apache.thrift.protocol.TList _list1135 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1135.size); + Partition _elem1136; + for (int _i1137 = 0; _i1137 < _list1135.size; ++_i1137) { - _elem1128 = new Partition(); - _elem1128.read(iprot); - struct.success.add(_elem1128); + _elem1136 = new Partition(); + _elem1136.read(iprot); + struct.success.add(_elem1136); } } struct.setSuccessIsSet(true); @@ -94032,13 +94032,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1130 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1130.size); - String _elem1131; - for (int _i1132 = 0; _i1132 < _list1130.size; ++_i1132) + org.apache.thrift.protocol.TList _list1138 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1138.size); + String _elem1139; + for (int _i1140 = 0; _i1140 < _list1138.size; ++_i1140) { - _elem1131 = iprot.readString(); - struct.part_vals.add(_elem1131); + _elem1139 = iprot.readString(); + struct.part_vals.add(_elem1139); } iprot.readListEnd(); } @@ -94058,13 +94058,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1133 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1133.size); - String _elem1134; - for (int _i1135 = 0; _i1135 < _list1133.size; ++_i1135) + org.apache.thrift.protocol.TList _list1141 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1141.size); + String _elem1142; + for (int _i1143 = 0; _i1143 < _list1141.size; ++_i1143) { - _elem1134 = iprot.readString(); - struct.group_names.add(_elem1134); + _elem1142 = iprot.readString(); + struct.group_names.add(_elem1142); } iprot.readListEnd(); } @@ -94100,9 +94100,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1136 : struct.part_vals) + for (String _iter1144 : struct.part_vals) { - oprot.writeString(_iter1136); + oprot.writeString(_iter1144); } oprot.writeListEnd(); } @@ -94117,9 +94117,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1137 : struct.group_names) + for (String _iter1145 : struct.group_names) { - oprot.writeString(_iter1137); + oprot.writeString(_iter1145); } oprot.writeListEnd(); } @@ -94168,9 +94168,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1138 : struct.part_vals) + for (String _iter1146 : struct.part_vals) { - oprot.writeString(_iter1138); + oprot.writeString(_iter1146); } } } @@ -94180,9 +94180,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1139 : struct.group_names) + for (String _iter1147 : struct.group_names) { - oprot.writeString(_iter1139); + oprot.writeString(_iter1147); } } } @@ -94202,13 +94202,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1140 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1140.size); - String _elem1141; - for (int _i1142 = 0; _i1142 < _list1140.size; ++_i1142) + org.apache.thrift.protocol.TList _list1148 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1148.size); + String _elem1149; + for (int _i1150 = 0; _i1150 < _list1148.size; ++_i1150) { - _elem1141 = iprot.readString(); - struct.part_vals.add(_elem1141); + _elem1149 = iprot.readString(); + struct.part_vals.add(_elem1149); } } struct.setPart_valsIsSet(true); @@ -94219,13 +94219,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1143 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1143.size); - String _elem1144; - for (int _i1145 = 0; _i1145 < _list1143.size; ++_i1145) + org.apache.thrift.protocol.TList _list1151 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1151.size); + String _elem1152; + for (int _i1153 = 0; _i1153 < _list1151.size; ++_i1153) { - _elem1144 = iprot.readString(); - struct.group_names.add(_elem1144); + _elem1152 = iprot.readString(); + struct.group_names.add(_elem1152); } } struct.setGroup_namesIsSet(true); @@ -96994,14 +96994,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1146 = iprot.readListBegin(); - struct.success = new ArrayList(_list1146.size); - Partition _elem1147; - for (int _i1148 = 0; _i1148 < _list1146.size; ++_i1148) + org.apache.thrift.protocol.TList _list1154 = iprot.readListBegin(); + struct.success = new ArrayList(_list1154.size); + Partition _elem1155; + for (int _i1156 = 0; _i1156 < _list1154.size; ++_i1156) { - _elem1147 = new Partition(); - _elem1147.read(iprot); - struct.success.add(_elem1147); + _elem1155 = new Partition(); + _elem1155.read(iprot); + struct.success.add(_elem1155); } iprot.readListEnd(); } @@ -97045,9 +97045,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1149 : struct.success) + for (Partition _iter1157 : struct.success) { - _iter1149.write(oprot); + _iter1157.write(oprot); } oprot.writeListEnd(); } @@ -97094,9 +97094,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1150 : struct.success) + for (Partition _iter1158 : struct.success) { - _iter1150.write(oprot); + _iter1158.write(oprot); } } } @@ -97114,14 +97114,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_resul BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1151 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1151.size); - Partition _elem1152; - for (int _i1153 = 0; _i1153 < _list1151.size; ++_i1153) + org.apache.thrift.protocol.TList _list1159 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1159.size); + Partition _elem1160; + for (int _i1161 = 0; _i1161 < _list1159.size; ++_i1161) { - _elem1152 = new Partition(); - _elem1152.read(iprot); - struct.success.add(_elem1152); + _elem1160 = new Partition(); + _elem1160.read(iprot); + struct.success.add(_elem1160); } } struct.setSuccessIsSet(true); @@ -97811,13 +97811,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1154 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1154.size); - String _elem1155; - for (int _i1156 = 0; _i1156 < _list1154.size; ++_i1156) + org.apache.thrift.protocol.TList _list1162 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1162.size); + String _elem1163; + for (int _i1164 = 0; _i1164 < _list1162.size; ++_i1164) { - _elem1155 = iprot.readString(); - struct.group_names.add(_elem1155); + _elem1163 = iprot.readString(); + struct.group_names.add(_elem1163); } iprot.readListEnd(); } @@ -97861,9 +97861,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1157 : struct.group_names) + for (String _iter1165 : struct.group_names) { - oprot.writeString(_iter1157); + oprot.writeString(_iter1165); } oprot.writeListEnd(); } @@ -97918,9 +97918,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1158 : struct.group_names) + for (String _iter1166 : struct.group_names) { - oprot.writeString(_iter1158); + oprot.writeString(_iter1166); } } } @@ -97948,13 +97948,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1159 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1159.size); - String _elem1160; - for (int _i1161 = 0; _i1161 < _list1159.size; ++_i1161) + org.apache.thrift.protocol.TList _list1167 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1167.size); + String _elem1168; + for (int _i1169 = 0; _i1169 < _list1167.size; ++_i1169) { - _elem1160 = iprot.readString(); - struct.group_names.add(_elem1160); + _elem1168 = iprot.readString(); + struct.group_names.add(_elem1168); } } struct.setGroup_namesIsSet(true); @@ -98441,14 +98441,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1162 = iprot.readListBegin(); - struct.success = new ArrayList(_list1162.size); - Partition _elem1163; - for (int _i1164 = 0; _i1164 < _list1162.size; ++_i1164) + org.apache.thrift.protocol.TList _list1170 = iprot.readListBegin(); + struct.success = new ArrayList(_list1170.size); + Partition _elem1171; + for (int _i1172 = 0; _i1172 < _list1170.size; ++_i1172) { - _elem1163 = new Partition(); - _elem1163.read(iprot); - struct.success.add(_elem1163); + _elem1171 = new Partition(); + _elem1171.read(iprot); + struct.success.add(_elem1171); } iprot.readListEnd(); } @@ -98492,9 +98492,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1165 : struct.success) + for (Partition _iter1173 : struct.success) { - _iter1165.write(oprot); + _iter1173.write(oprot); } oprot.writeListEnd(); } @@ -98541,9 +98541,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1166 : struct.success) + for (Partition _iter1174 : struct.success) { - _iter1166.write(oprot); + _iter1174.write(oprot); } } } @@ -98561,14 +98561,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1167 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1167.size); - Partition _elem1168; - for (int _i1169 = 0; _i1169 < _list1167.size; ++_i1169) + org.apache.thrift.protocol.TList _list1175 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1175.size); + Partition _elem1176; + for (int _i1177 = 0; _i1177 < _list1175.size; ++_i1177) { - _elem1168 = new Partition(); - _elem1168.read(iprot); - struct.success.add(_elem1168); + _elem1176 = new Partition(); + _elem1176.read(iprot); + struct.success.add(_elem1176); } } struct.setSuccessIsSet(true); @@ -99631,14 +99631,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_pspe case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1170 = iprot.readListBegin(); - struct.success = new ArrayList(_list1170.size); - PartitionSpec _elem1171; - for (int _i1172 = 0; _i1172 < _list1170.size; ++_i1172) + org.apache.thrift.protocol.TList _list1178 = iprot.readListBegin(); + struct.success = new ArrayList(_list1178.size); + PartitionSpec _elem1179; + for (int _i1180 = 0; _i1180 < _list1178.size; ++_i1180) { - _elem1171 = new PartitionSpec(); - _elem1171.read(iprot); - struct.success.add(_elem1171); + _elem1179 = new PartitionSpec(); + _elem1179.read(iprot); + struct.success.add(_elem1179); } iprot.readListEnd(); } @@ -99682,9 +99682,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_psp oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter1173 : struct.success) + for (PartitionSpec _iter1181 : struct.success) { - _iter1173.write(oprot); + _iter1181.write(oprot); } oprot.writeListEnd(); } @@ -99731,9 +99731,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspe if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1174 : struct.success) + for (PartitionSpec _iter1182 : struct.success) { - _iter1174.write(oprot); + _iter1182.write(oprot); } } } @@ -99751,14 +99751,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspec BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1175 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1175.size); - PartitionSpec _elem1176; - for (int _i1177 = 0; _i1177 < _list1175.size; ++_i1177) + org.apache.thrift.protocol.TList _list1183 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1183.size); + PartitionSpec _elem1184; + for (int _i1185 = 0; _i1185 < _list1183.size; ++_i1185) { - _elem1176 = new PartitionSpec(); - _elem1176.read(iprot); - struct.success.add(_elem1176); + _elem1184 = new PartitionSpec(); + _elem1184.read(iprot); + struct.success.add(_elem1184); } } struct.setSuccessIsSet(true); @@ -100818,13 +100818,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1178 = iprot.readListBegin(); - struct.success = new ArrayList(_list1178.size); - String _elem1179; - for (int _i1180 = 0; _i1180 < _list1178.size; ++_i1180) + org.apache.thrift.protocol.TList _list1186 = iprot.readListBegin(); + struct.success = new ArrayList(_list1186.size); + String _elem1187; + for (int _i1188 = 0; _i1188 < _list1186.size; ++_i1188) { - _elem1179 = iprot.readString(); - struct.success.add(_elem1179); + _elem1187 = iprot.readString(); + struct.success.add(_elem1187); } iprot.readListEnd(); } @@ -100868,9 +100868,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1181 : struct.success) + for (String _iter1189 : struct.success) { - oprot.writeString(_iter1181); + oprot.writeString(_iter1189); } oprot.writeListEnd(); } @@ -100917,9 +100917,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1182 : struct.success) + for (String _iter1190 : struct.success) { - oprot.writeString(_iter1182); + oprot.writeString(_iter1190); } } } @@ -100937,13 +100937,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1183 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1183.size); - String _elem1184; - for (int _i1185 = 0; _i1185 < _list1183.size; ++_i1185) + org.apache.thrift.protocol.TList _list1191 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1191.size); + String _elem1192; + for (int _i1193 = 0; _i1193 < _list1191.size; ++_i1193) { - _elem1184 = iprot.readString(); - struct.success.add(_elem1184); + _elem1192 = iprot.readString(); + struct.success.add(_elem1192); } } struct.setSuccessIsSet(true); @@ -102474,13 +102474,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_a case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1186 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1186.size); - String _elem1187; - for (int _i1188 = 0; _i1188 < _list1186.size; ++_i1188) + org.apache.thrift.protocol.TList _list1194 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1194.size); + String _elem1195; + for (int _i1196 = 0; _i1196 < _list1194.size; ++_i1196) { - _elem1187 = iprot.readString(); - struct.part_vals.add(_elem1187); + _elem1195 = iprot.readString(); + struct.part_vals.add(_elem1195); } iprot.readListEnd(); } @@ -102524,9 +102524,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1189 : struct.part_vals) + for (String _iter1197 : struct.part_vals) { - oprot.writeString(_iter1189); + oprot.writeString(_iter1197); } oprot.writeListEnd(); } @@ -102575,9 +102575,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_a if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1190 : struct.part_vals) + for (String _iter1198 : struct.part_vals) { - oprot.writeString(_iter1190); + oprot.writeString(_iter1198); } } } @@ -102600,13 +102600,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1191 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1191.size); - String _elem1192; - for (int _i1193 = 0; _i1193 < _list1191.size; ++_i1193) + org.apache.thrift.protocol.TList _list1199 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1199.size); + String _elem1200; + for (int _i1201 = 0; _i1201 < _list1199.size; ++_i1201) { - _elem1192 = iprot.readString(); - struct.part_vals.add(_elem1192); + _elem1200 = iprot.readString(); + struct.part_vals.add(_elem1200); } } struct.setPart_valsIsSet(true); @@ -103097,14 +103097,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1194 = iprot.readListBegin(); - struct.success = new ArrayList(_list1194.size); - Partition _elem1195; - for (int _i1196 = 0; _i1196 < _list1194.size; ++_i1196) + org.apache.thrift.protocol.TList _list1202 = iprot.readListBegin(); + struct.success = new ArrayList(_list1202.size); + Partition _elem1203; + for (int _i1204 = 0; _i1204 < _list1202.size; ++_i1204) { - _elem1195 = new Partition(); - _elem1195.read(iprot); - struct.success.add(_elem1195); + _elem1203 = new Partition(); + _elem1203.read(iprot); + struct.success.add(_elem1203); } iprot.readListEnd(); } @@ -103148,9 +103148,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1197 : struct.success) + for (Partition _iter1205 : struct.success) { - _iter1197.write(oprot); + _iter1205.write(oprot); } oprot.writeListEnd(); } @@ -103197,9 +103197,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1198 : struct.success) + for (Partition _iter1206 : struct.success) { - _iter1198.write(oprot); + _iter1206.write(oprot); } } } @@ -103217,14 +103217,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_re BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1199 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1199.size); - Partition _elem1200; - for (int _i1201 = 0; _i1201 < _list1199.size; ++_i1201) + org.apache.thrift.protocol.TList _list1207 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1207.size); + Partition _elem1208; + for (int _i1209 = 0; _i1209 < _list1207.size; ++_i1209) { - _elem1200 = new Partition(); - _elem1200.read(iprot); - struct.success.add(_elem1200); + _elem1208 = new Partition(); + _elem1208.read(iprot); + struct.success.add(_elem1208); } } struct.setSuccessIsSet(true); @@ -103996,13 +103996,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1202 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1202.size); - String _elem1203; - for (int _i1204 = 0; _i1204 < _list1202.size; ++_i1204) + org.apache.thrift.protocol.TList _list1210 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1210.size); + String _elem1211; + for (int _i1212 = 0; _i1212 < _list1210.size; ++_i1212) { - _elem1203 = iprot.readString(); - struct.part_vals.add(_elem1203); + _elem1211 = iprot.readString(); + struct.part_vals.add(_elem1211); } iprot.readListEnd(); } @@ -104030,13 +104030,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 6: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1205 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1205.size); - String _elem1206; - for (int _i1207 = 0; _i1207 < _list1205.size; ++_i1207) + org.apache.thrift.protocol.TList _list1213 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1213.size); + String _elem1214; + for (int _i1215 = 0; _i1215 < _list1213.size; ++_i1215) { - _elem1206 = iprot.readString(); - struct.group_names.add(_elem1206); + _elem1214 = iprot.readString(); + struct.group_names.add(_elem1214); } iprot.readListEnd(); } @@ -104072,9 +104072,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1208 : struct.part_vals) + for (String _iter1216 : struct.part_vals) { - oprot.writeString(_iter1208); + oprot.writeString(_iter1216); } oprot.writeListEnd(); } @@ -104092,9 +104092,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1209 : struct.group_names) + for (String _iter1217 : struct.group_names) { - oprot.writeString(_iter1209); + oprot.writeString(_iter1217); } oprot.writeListEnd(); } @@ -104146,9 +104146,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1210 : struct.part_vals) + for (String _iter1218 : struct.part_vals) { - oprot.writeString(_iter1210); + oprot.writeString(_iter1218); } } } @@ -104161,9 +104161,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1211 : struct.group_names) + for (String _iter1219 : struct.group_names) { - oprot.writeString(_iter1211); + oprot.writeString(_iter1219); } } } @@ -104183,13 +104183,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1212 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1212.size); - String _elem1213; - for (int _i1214 = 0; _i1214 < _list1212.size; ++_i1214) + org.apache.thrift.protocol.TList _list1220 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1220.size); + String _elem1221; + for (int _i1222 = 0; _i1222 < _list1220.size; ++_i1222) { - _elem1213 = iprot.readString(); - struct.part_vals.add(_elem1213); + _elem1221 = iprot.readString(); + struct.part_vals.add(_elem1221); } } struct.setPart_valsIsSet(true); @@ -104204,13 +104204,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list1215 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1215.size); - String _elem1216; - for (int _i1217 = 0; _i1217 < _list1215.size; ++_i1217) + org.apache.thrift.protocol.TList _list1223 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1223.size); + String _elem1224; + for (int _i1225 = 0; _i1225 < _list1223.size; ++_i1225) { - _elem1216 = iprot.readString(); - struct.group_names.add(_elem1216); + _elem1224 = iprot.readString(); + struct.group_names.add(_elem1224); } } struct.setGroup_namesIsSet(true); @@ -104697,14 +104697,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1218 = iprot.readListBegin(); - struct.success = new ArrayList(_list1218.size); - Partition _elem1219; - for (int _i1220 = 0; _i1220 < _list1218.size; ++_i1220) + org.apache.thrift.protocol.TList _list1226 = iprot.readListBegin(); + struct.success = new ArrayList(_list1226.size); + Partition _elem1227; + for (int _i1228 = 0; _i1228 < _list1226.size; ++_i1228) { - _elem1219 = new Partition(); - _elem1219.read(iprot); - struct.success.add(_elem1219); + _elem1227 = new Partition(); + _elem1227.read(iprot); + struct.success.add(_elem1227); } iprot.readListEnd(); } @@ -104748,9 +104748,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1221 : struct.success) + for (Partition _iter1229 : struct.success) { - _iter1221.write(oprot); + _iter1229.write(oprot); } oprot.writeListEnd(); } @@ -104797,9 +104797,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1222 : struct.success) + for (Partition _iter1230 : struct.success) { - _iter1222.write(oprot); + _iter1230.write(oprot); } } } @@ -104817,14 +104817,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1223 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1223.size); - Partition _elem1224; - for (int _i1225 = 0; _i1225 < _list1223.size; ++_i1225) + org.apache.thrift.protocol.TList _list1231 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1231.size); + Partition _elem1232; + for (int _i1233 = 0; _i1233 < _list1231.size; ++_i1233) { - _elem1224 = new Partition(); - _elem1224.read(iprot); - struct.success.add(_elem1224); + _elem1232 = new Partition(); + _elem1232.read(iprot); + struct.success.add(_elem1232); } } struct.setSuccessIsSet(true); @@ -105417,13 +105417,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1226 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1226.size); - String _elem1227; - for (int _i1228 = 0; _i1228 < _list1226.size; ++_i1228) + org.apache.thrift.protocol.TList _list1234 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1234.size); + String _elem1235; + for (int _i1236 = 0; _i1236 < _list1234.size; ++_i1236) { - _elem1227 = iprot.readString(); - struct.part_vals.add(_elem1227); + _elem1235 = iprot.readString(); + struct.part_vals.add(_elem1235); } iprot.readListEnd(); } @@ -105467,9 +105467,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1229 : struct.part_vals) + for (String _iter1237 : struct.part_vals) { - oprot.writeString(_iter1229); + oprot.writeString(_iter1237); } oprot.writeListEnd(); } @@ -105518,9 +105518,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1230 : struct.part_vals) + for (String _iter1238 : struct.part_vals) { - oprot.writeString(_iter1230); + oprot.writeString(_iter1238); } } } @@ -105543,13 +105543,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1231 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1231.size); - String _elem1232; - for (int _i1233 = 0; _i1233 < _list1231.size; ++_i1233) + org.apache.thrift.protocol.TList _list1239 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1239.size); + String _elem1240; + for (int _i1241 = 0; _i1241 < _list1239.size; ++_i1241) { - _elem1232 = iprot.readString(); - struct.part_vals.add(_elem1232); + _elem1240 = iprot.readString(); + struct.part_vals.add(_elem1240); } } struct.setPart_valsIsSet(true); @@ -106037,13 +106037,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1234 = iprot.readListBegin(); - struct.success = new ArrayList(_list1234.size); - String _elem1235; - for (int _i1236 = 0; _i1236 < _list1234.size; ++_i1236) + org.apache.thrift.protocol.TList _list1242 = iprot.readListBegin(); + struct.success = new ArrayList(_list1242.size); + String _elem1243; + for (int _i1244 = 0; _i1244 < _list1242.size; ++_i1244) { - _elem1235 = iprot.readString(); - struct.success.add(_elem1235); + _elem1243 = iprot.readString(); + struct.success.add(_elem1243); } iprot.readListEnd(); } @@ -106087,9 +106087,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1237 : struct.success) + for (String _iter1245 : struct.success) { - oprot.writeString(_iter1237); + oprot.writeString(_iter1245); } oprot.writeListEnd(); } @@ -106136,9 +106136,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1238 : struct.success) + for (String _iter1246 : struct.success) { - oprot.writeString(_iter1238); + oprot.writeString(_iter1246); } } } @@ -106156,13 +106156,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1239 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1239.size); - String _elem1240; - for (int _i1241 = 0; _i1241 < _list1239.size; ++_i1241) + org.apache.thrift.protocol.TList _list1247 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1247.size); + String _elem1248; + for (int _i1249 = 0; _i1249 < _list1247.size; ++_i1249) { - _elem1240 = iprot.readString(); - struct.success.add(_elem1240); + _elem1248 = iprot.readString(); + struct.success.add(_elem1248); } } struct.setSuccessIsSet(true); @@ -107329,14 +107329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1242 = iprot.readListBegin(); - struct.success = new ArrayList(_list1242.size); - Partition _elem1243; - for (int _i1244 = 0; _i1244 < _list1242.size; ++_i1244) + org.apache.thrift.protocol.TList _list1250 = iprot.readListBegin(); + struct.success = new ArrayList(_list1250.size); + Partition _elem1251; + for (int _i1252 = 0; _i1252 < _list1250.size; ++_i1252) { - _elem1243 = new Partition(); - _elem1243.read(iprot); - struct.success.add(_elem1243); + _elem1251 = new Partition(); + _elem1251.read(iprot); + struct.success.add(_elem1251); } iprot.readListEnd(); } @@ -107380,9 +107380,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1245 : struct.success) + for (Partition _iter1253 : struct.success) { - _iter1245.write(oprot); + _iter1253.write(oprot); } oprot.writeListEnd(); } @@ -107429,9 +107429,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1246 : struct.success) + for (Partition _iter1254 : struct.success) { - _iter1246.write(oprot); + _iter1254.write(oprot); } } } @@ -107449,14 +107449,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1247 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1247.size); - Partition _elem1248; - for (int _i1249 = 0; _i1249 < _list1247.size; ++_i1249) + org.apache.thrift.protocol.TList _list1255 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1255.size); + Partition _elem1256; + for (int _i1257 = 0; _i1257 < _list1255.size; ++_i1257) { - _elem1248 = new Partition(); - _elem1248.read(iprot); - struct.success.add(_elem1248); + _elem1256 = new Partition(); + _elem1256.read(iprot); + struct.success.add(_elem1256); } } struct.setSuccessIsSet(true); @@ -108623,14 +108623,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_part_specs_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1250 = iprot.readListBegin(); - struct.success = new ArrayList(_list1250.size); - PartitionSpec _elem1251; - for (int _i1252 = 0; _i1252 < _list1250.size; ++_i1252) + org.apache.thrift.protocol.TList _list1258 = iprot.readListBegin(); + struct.success = new ArrayList(_list1258.size); + PartitionSpec _elem1259; + for (int _i1260 = 0; _i1260 < _list1258.size; ++_i1260) { - _elem1251 = new PartitionSpec(); - _elem1251.read(iprot); - struct.success.add(_elem1251); + _elem1259 = new PartitionSpec(); + _elem1259.read(iprot); + struct.success.add(_elem1259); } iprot.readListEnd(); } @@ -108674,9 +108674,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_part_specs_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter1253 : struct.success) + for (PartitionSpec _iter1261 : struct.success) { - _iter1253.write(oprot); + _iter1261.write(oprot); } oprot.writeListEnd(); } @@ -108723,9 +108723,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1254 : struct.success) + for (PartitionSpec _iter1262 : struct.success) { - _iter1254.write(oprot); + _iter1262.write(oprot); } } } @@ -108743,14 +108743,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1255 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1255.size); - PartitionSpec _elem1256; - for (int _i1257 = 0; _i1257 < _list1255.size; ++_i1257) + org.apache.thrift.protocol.TList _list1263 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1263.size); + PartitionSpec _elem1264; + for (int _i1265 = 0; _i1265 < _list1263.size; ++_i1265) { - _elem1256 = new PartitionSpec(); - _elem1256.read(iprot); - struct.success.add(_elem1256); + _elem1264 = new PartitionSpec(); + _elem1264.read(iprot); + struct.success.add(_elem1264); } } struct.setSuccessIsSet(true); @@ -111334,13 +111334,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 3: // NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1258 = iprot.readListBegin(); - struct.names = new ArrayList(_list1258.size); - String _elem1259; - for (int _i1260 = 0; _i1260 < _list1258.size; ++_i1260) + org.apache.thrift.protocol.TList _list1266 = iprot.readListBegin(); + struct.names = new ArrayList(_list1266.size); + String _elem1267; + for (int _i1268 = 0; _i1268 < _list1266.size; ++_i1268) { - _elem1259 = iprot.readString(); - struct.names.add(_elem1259); + _elem1267 = iprot.readString(); + struct.names.add(_elem1267); } iprot.readListEnd(); } @@ -111376,9 +111376,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.names.size())); - for (String _iter1261 : struct.names) + for (String _iter1269 : struct.names) { - oprot.writeString(_iter1261); + oprot.writeString(_iter1269); } oprot.writeListEnd(); } @@ -111421,9 +111421,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (String _iter1262 : struct.names) + for (String _iter1270 : struct.names) { - oprot.writeString(_iter1262); + oprot.writeString(_iter1270); } } } @@ -111443,13 +111443,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1263 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.names = new ArrayList(_list1263.size); - String _elem1264; - for (int _i1265 = 0; _i1265 < _list1263.size; ++_i1265) + org.apache.thrift.protocol.TList _list1271 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.names = new ArrayList(_list1271.size); + String _elem1272; + for (int _i1273 = 0; _i1273 < _list1271.size; ++_i1273) { - _elem1264 = iprot.readString(); - struct.names.add(_elem1264); + _elem1272 = iprot.readString(); + struct.names.add(_elem1272); } } struct.setNamesIsSet(true); @@ -111936,14 +111936,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1266 = iprot.readListBegin(); - struct.success = new ArrayList(_list1266.size); - Partition _elem1267; - for (int _i1268 = 0; _i1268 < _list1266.size; ++_i1268) + org.apache.thrift.protocol.TList _list1274 = iprot.readListBegin(); + struct.success = new ArrayList(_list1274.size); + Partition _elem1275; + for (int _i1276 = 0; _i1276 < _list1274.size; ++_i1276) { - _elem1267 = new Partition(); - _elem1267.read(iprot); - struct.success.add(_elem1267); + _elem1275 = new Partition(); + _elem1275.read(iprot); + struct.success.add(_elem1275); } iprot.readListEnd(); } @@ -111987,9 +111987,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1269 : struct.success) + for (Partition _iter1277 : struct.success) { - _iter1269.write(oprot); + _iter1277.write(oprot); } oprot.writeListEnd(); } @@ -112036,9 +112036,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1270 : struct.success) + for (Partition _iter1278 : struct.success) { - _iter1270.write(oprot); + _iter1278.write(oprot); } } } @@ -112056,14 +112056,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1271 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1271.size); - Partition _elem1272; - for (int _i1273 = 0; _i1273 < _list1271.size; ++_i1273) + org.apache.thrift.protocol.TList _list1279 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1279.size); + Partition _elem1280; + for (int _i1281 = 0; _i1281 < _list1279.size; ++_i1281) { - _elem1272 = new Partition(); - _elem1272.read(iprot); - struct.success.add(_elem1272); + _elem1280 = new Partition(); + _elem1280.read(iprot); + struct.success.add(_elem1280); } } struct.setSuccessIsSet(true); @@ -113613,14 +113613,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_ar case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1274 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1274.size); - Partition _elem1275; - for (int _i1276 = 0; _i1276 < _list1274.size; ++_i1276) + org.apache.thrift.protocol.TList _list1282 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1282.size); + Partition _elem1283; + for (int _i1284 = 0; _i1284 < _list1282.size; ++_i1284) { - _elem1275 = new Partition(); - _elem1275.read(iprot); - struct.new_parts.add(_elem1275); + _elem1283 = new Partition(); + _elem1283.read(iprot); + struct.new_parts.add(_elem1283); } iprot.readListEnd(); } @@ -113656,9 +113656,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_a oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1277 : struct.new_parts) + for (Partition _iter1285 : struct.new_parts) { - _iter1277.write(oprot); + _iter1285.write(oprot); } oprot.writeListEnd(); } @@ -113701,9 +113701,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_ar if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1278 : struct.new_parts) + for (Partition _iter1286 : struct.new_parts) { - _iter1278.write(oprot); + _iter1286.write(oprot); } } } @@ -113723,14 +113723,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1279 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1279.size); - Partition _elem1280; - for (int _i1281 = 0; _i1281 < _list1279.size; ++_i1281) + org.apache.thrift.protocol.TList _list1287 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1287.size); + Partition _elem1288; + for (int _i1289 = 0; _i1289 < _list1287.size; ++_i1289) { - _elem1280 = new Partition(); - _elem1280.read(iprot); - struct.new_parts.add(_elem1280); + _elem1288 = new Partition(); + _elem1288.read(iprot); + struct.new_parts.add(_elem1288); } } struct.setNew_partsIsSet(true); @@ -114783,14 +114783,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_wi case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1282 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1282.size); - Partition _elem1283; - for (int _i1284 = 0; _i1284 < _list1282.size; ++_i1284) + org.apache.thrift.protocol.TList _list1290 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1290.size); + Partition _elem1291; + for (int _i1292 = 0; _i1292 < _list1290.size; ++_i1292) { - _elem1283 = new Partition(); - _elem1283.read(iprot); - struct.new_parts.add(_elem1283); + _elem1291 = new Partition(); + _elem1291.read(iprot); + struct.new_parts.add(_elem1291); } iprot.readListEnd(); } @@ -114835,9 +114835,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_w oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1285 : struct.new_parts) + for (Partition _iter1293 : struct.new_parts) { - _iter1285.write(oprot); + _iter1293.write(oprot); } oprot.writeListEnd(); } @@ -114888,9 +114888,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wi if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1286 : struct.new_parts) + for (Partition _iter1294 : struct.new_parts) { - _iter1286.write(oprot); + _iter1294.write(oprot); } } } @@ -114913,14 +114913,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1287 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1287.size); - Partition _elem1288; - for (int _i1289 = 0; _i1289 < _list1287.size; ++_i1289) + org.apache.thrift.protocol.TList _list1295 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1295.size); + Partition _elem1296; + for (int _i1297 = 0; _i1297 < _list1295.size; ++_i1297) { - _elem1288 = new Partition(); - _elem1288.read(iprot); - struct.new_parts.add(_elem1288); + _elem1296 = new Partition(); + _elem1296.read(iprot); + struct.new_parts.add(_elem1296); } } struct.setNew_partsIsSet(true); @@ -117121,13 +117121,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, rename_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1290 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1290.size); - String _elem1291; - for (int _i1292 = 0; _i1292 < _list1290.size; ++_i1292) + org.apache.thrift.protocol.TList _list1298 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1298.size); + String _elem1299; + for (int _i1300 = 0; _i1300 < _list1298.size; ++_i1300) { - _elem1291 = iprot.readString(); - struct.part_vals.add(_elem1291); + _elem1299 = iprot.readString(); + struct.part_vals.add(_elem1299); } iprot.readListEnd(); } @@ -117172,9 +117172,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, rename_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1293 : struct.part_vals) + for (String _iter1301 : struct.part_vals) { - oprot.writeString(_iter1293); + oprot.writeString(_iter1301); } oprot.writeListEnd(); } @@ -117225,9 +117225,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, rename_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1294 : struct.part_vals) + for (String _iter1302 : struct.part_vals) { - oprot.writeString(_iter1294); + oprot.writeString(_iter1302); } } } @@ -117250,13 +117250,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1295 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1295.size); - String _elem1296; - for (int _i1297 = 0; _i1297 < _list1295.size; ++_i1297) + org.apache.thrift.protocol.TList _list1303 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1303.size); + String _elem1304; + for (int _i1305 = 0; _i1305 < _list1303.size; ++_i1305) { - _elem1296 = iprot.readString(); - struct.part_vals.add(_elem1296); + _elem1304 = iprot.readString(); + struct.part_vals.add(_elem1304); } } struct.setPart_valsIsSet(true); @@ -118130,13 +118130,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_ case 1: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1298 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1298.size); - String _elem1299; - for (int _i1300 = 0; _i1300 < _list1298.size; ++_i1300) + org.apache.thrift.protocol.TList _list1306 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1306.size); + String _elem1307; + for (int _i1308 = 0; _i1308 < _list1306.size; ++_i1308) { - _elem1299 = iprot.readString(); - struct.part_vals.add(_elem1299); + _elem1307 = iprot.readString(); + struct.part_vals.add(_elem1307); } iprot.readListEnd(); } @@ -118170,9 +118170,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1301 : struct.part_vals) + for (String _iter1309 : struct.part_vals) { - oprot.writeString(_iter1301); + oprot.writeString(_iter1309); } oprot.writeListEnd(); } @@ -118209,9 +118209,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1302 : struct.part_vals) + for (String _iter1310 : struct.part_vals) { - oprot.writeString(_iter1302); + oprot.writeString(_iter1310); } } } @@ -118226,13 +118226,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_v BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1303 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1303.size); - String _elem1304; - for (int _i1305 = 0; _i1305 < _list1303.size; ++_i1305) + org.apache.thrift.protocol.TList _list1311 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1311.size); + String _elem1312; + for (int _i1313 = 0; _i1313 < _list1311.size; ++_i1313) { - _elem1304 = iprot.readString(); - struct.part_vals.add(_elem1304); + _elem1312 = iprot.readString(); + struct.part_vals.add(_elem1312); } } struct.setPart_valsIsSet(true); @@ -120387,13 +120387,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_v case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1306 = iprot.readListBegin(); - struct.success = new ArrayList(_list1306.size); - String _elem1307; - for (int _i1308 = 0; _i1308 < _list1306.size; ++_i1308) + org.apache.thrift.protocol.TList _list1314 = iprot.readListBegin(); + struct.success = new ArrayList(_list1314.size); + String _elem1315; + for (int _i1316 = 0; _i1316 < _list1314.size; ++_i1316) { - _elem1307 = iprot.readString(); - struct.success.add(_elem1307); + _elem1315 = iprot.readString(); + struct.success.add(_elem1315); } iprot.readListEnd(); } @@ -120428,9 +120428,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1309 : struct.success) + for (String _iter1317 : struct.success) { - oprot.writeString(_iter1309); + oprot.writeString(_iter1317); } oprot.writeListEnd(); } @@ -120469,9 +120469,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1310 : struct.success) + for (String _iter1318 : struct.success) { - oprot.writeString(_iter1310); + oprot.writeString(_iter1318); } } } @@ -120486,13 +120486,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_va BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1311 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1311.size); - String _elem1312; - for (int _i1313 = 0; _i1313 < _list1311.size; ++_i1313) + org.apache.thrift.protocol.TList _list1319 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1319.size); + String _elem1320; + for (int _i1321 = 0; _i1321 < _list1319.size; ++_i1321) { - _elem1312 = iprot.readString(); - struct.success.add(_elem1312); + _elem1320 = iprot.readString(); + struct.success.add(_elem1320); } } struct.setSuccessIsSet(true); @@ -121255,15 +121255,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1314 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map1314.size); - String _key1315; - String _val1316; - for (int _i1317 = 0; _i1317 < _map1314.size; ++_i1317) + org.apache.thrift.protocol.TMap _map1322 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map1322.size); + String _key1323; + String _val1324; + for (int _i1325 = 0; _i1325 < _map1322.size; ++_i1325) { - _key1315 = iprot.readString(); - _val1316 = iprot.readString(); - struct.success.put(_key1315, _val1316); + _key1323 = iprot.readString(); + _val1324 = iprot.readString(); + struct.success.put(_key1323, _val1324); } iprot.readMapEnd(); } @@ -121298,10 +121298,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (Map.Entry _iter1318 : struct.success.entrySet()) + for (Map.Entry _iter1326 : struct.success.entrySet()) { - oprot.writeString(_iter1318.getKey()); - oprot.writeString(_iter1318.getValue()); + oprot.writeString(_iter1326.getKey()); + oprot.writeString(_iter1326.getValue()); } oprot.writeMapEnd(); } @@ -121340,10 +121340,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter1319 : struct.success.entrySet()) + for (Map.Entry _iter1327 : struct.success.entrySet()) { - oprot.writeString(_iter1319.getKey()); - oprot.writeString(_iter1319.getValue()); + oprot.writeString(_iter1327.getKey()); + oprot.writeString(_iter1327.getValue()); } } } @@ -121358,15 +121358,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_sp BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1320 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map1320.size); - String _key1321; - String _val1322; - for (int _i1323 = 0; _i1323 < _map1320.size; ++_i1323) + org.apache.thrift.protocol.TMap _map1328 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap(2*_map1328.size); + String _key1329; + String _val1330; + for (int _i1331 = 0; _i1331 < _map1328.size; ++_i1331) { - _key1321 = iprot.readString(); - _val1322 = iprot.readString(); - struct.success.put(_key1321, _val1322); + _key1329 = iprot.readString(); + _val1330 = iprot.readString(); + struct.success.put(_key1329, _val1330); } } struct.setSuccessIsSet(true); @@ -121961,15 +121961,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, markPartitionForEve case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1324 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1324.size); - String _key1325; - String _val1326; - for (int _i1327 = 0; _i1327 < _map1324.size; ++_i1327) + org.apache.thrift.protocol.TMap _map1332 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1332.size); + String _key1333; + String _val1334; + for (int _i1335 = 0; _i1335 < _map1332.size; ++_i1335) { - _key1325 = iprot.readString(); - _val1326 = iprot.readString(); - struct.part_vals.put(_key1325, _val1326); + _key1333 = iprot.readString(); + _val1334 = iprot.readString(); + struct.part_vals.put(_key1333, _val1334); } iprot.readMapEnd(); } @@ -122013,10 +122013,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, markPartitionForEv oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1328 : struct.part_vals.entrySet()) + for (Map.Entry _iter1336 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1328.getKey()); - oprot.writeString(_iter1328.getValue()); + oprot.writeString(_iter1336.getKey()); + oprot.writeString(_iter1336.getValue()); } oprot.writeMapEnd(); } @@ -122067,10 +122067,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1329 : struct.part_vals.entrySet()) + for (Map.Entry _iter1337 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1329.getKey()); - oprot.writeString(_iter1329.getValue()); + oprot.writeString(_iter1337.getKey()); + oprot.writeString(_iter1337.getValue()); } } } @@ -122093,15 +122093,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1330 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1330.size); - String _key1331; - String _val1332; - for (int _i1333 = 0; _i1333 < _map1330.size; ++_i1333) + org.apache.thrift.protocol.TMap _map1338 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1338.size); + String _key1339; + String _val1340; + for (int _i1341 = 0; _i1341 < _map1338.size; ++_i1341) { - _key1331 = iprot.readString(); - _val1332 = iprot.readString(); - struct.part_vals.put(_key1331, _val1332); + _key1339 = iprot.readString(); + _val1340 = iprot.readString(); + struct.part_vals.put(_key1339, _val1340); } } struct.setPart_valsIsSet(true); @@ -123585,15 +123585,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, isPartitionMarkedFo case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1334 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1334.size); - String _key1335; - String _val1336; - for (int _i1337 = 0; _i1337 < _map1334.size; ++_i1337) + org.apache.thrift.protocol.TMap _map1342 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1342.size); + String _key1343; + String _val1344; + for (int _i1345 = 0; _i1345 < _map1342.size; ++_i1345) { - _key1335 = iprot.readString(); - _val1336 = iprot.readString(); - struct.part_vals.put(_key1335, _val1336); + _key1343 = iprot.readString(); + _val1344 = iprot.readString(); + struct.part_vals.put(_key1343, _val1344); } iprot.readMapEnd(); } @@ -123637,10 +123637,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, isPartitionMarkedF oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1338 : struct.part_vals.entrySet()) + for (Map.Entry _iter1346 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1338.getKey()); - oprot.writeString(_iter1338.getValue()); + oprot.writeString(_iter1346.getKey()); + oprot.writeString(_iter1346.getValue()); } oprot.writeMapEnd(); } @@ -123691,10 +123691,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1339 : struct.part_vals.entrySet()) + for (Map.Entry _iter1347 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1339.getKey()); - oprot.writeString(_iter1339.getValue()); + oprot.writeString(_iter1347.getKey()); + oprot.writeString(_iter1347.getValue()); } } } @@ -123717,15 +123717,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1340 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1340.size); - String _key1341; - String _val1342; - for (int _i1343 = 0; _i1343 < _map1340.size; ++_i1343) + org.apache.thrift.protocol.TMap _map1348 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1348.size); + String _key1349; + String _val1350; + for (int _i1351 = 0; _i1351 < _map1348.size; ++_i1351) { - _key1341 = iprot.readString(); - _val1342 = iprot.readString(); - struct.part_vals.put(_key1341, _val1342); + _key1349 = iprot.readString(); + _val1350 = iprot.readString(); + struct.part_vals.put(_key1349, _val1350); } } struct.setPart_valsIsSet(true); @@ -130449,14 +130449,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_indexes_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1344 = iprot.readListBegin(); - struct.success = new ArrayList(_list1344.size); - Index _elem1345; - for (int _i1346 = 0; _i1346 < _list1344.size; ++_i1346) + org.apache.thrift.protocol.TList _list1352 = iprot.readListBegin(); + struct.success = new ArrayList(_list1352.size); + Index _elem1353; + for (int _i1354 = 0; _i1354 < _list1352.size; ++_i1354) { - _elem1345 = new Index(); - _elem1345.read(iprot); - struct.success.add(_elem1345); + _elem1353 = new Index(); + _elem1353.read(iprot); + struct.success.add(_elem1353); } iprot.readListEnd(); } @@ -130500,9 +130500,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_indexes_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Index _iter1347 : struct.success) + for (Index _iter1355 : struct.success) { - _iter1347.write(oprot); + _iter1355.write(oprot); } oprot.writeListEnd(); } @@ -130549,9 +130549,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_indexes_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter1348 : struct.success) + for (Index _iter1356 : struct.success) { - _iter1348.write(oprot); + _iter1356.write(oprot); } } } @@ -130569,14 +130569,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_indexes_result s BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1349 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1349.size); - Index _elem1350; - for (int _i1351 = 0; _i1351 < _list1349.size; ++_i1351) + org.apache.thrift.protocol.TList _list1357 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1357.size); + Index _elem1358; + for (int _i1359 = 0; _i1359 < _list1357.size; ++_i1359) { - _elem1350 = new Index(); - _elem1350.read(iprot); - struct.success.add(_elem1350); + _elem1358 = new Index(); + _elem1358.read(iprot); + struct.success.add(_elem1358); } } struct.setSuccessIsSet(true); @@ -131555,13 +131555,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_index_names_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1352 = iprot.readListBegin(); - struct.success = new ArrayList(_list1352.size); - String _elem1353; - for (int _i1354 = 0; _i1354 < _list1352.size; ++_i1354) + org.apache.thrift.protocol.TList _list1360 = iprot.readListBegin(); + struct.success = new ArrayList(_list1360.size); + String _elem1361; + for (int _i1362 = 0; _i1362 < _list1360.size; ++_i1362) { - _elem1353 = iprot.readString(); - struct.success.add(_elem1353); + _elem1361 = iprot.readString(); + struct.success.add(_elem1361); } iprot.readListEnd(); } @@ -131596,9 +131596,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_index_names_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1355 : struct.success) + for (String _iter1363 : struct.success) { - oprot.writeString(_iter1355); + oprot.writeString(_iter1363); } oprot.writeListEnd(); } @@ -131637,9 +131637,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_index_names_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1356 : struct.success) + for (String _iter1364 : struct.success) { - oprot.writeString(_iter1356); + oprot.writeString(_iter1364); } } } @@ -131654,13 +131654,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_index_names_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1357 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1357.size); - String _elem1358; - for (int _i1359 = 0; _i1359 < _list1357.size; ++_i1359) + org.apache.thrift.protocol.TList _list1365 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1365.size); + String _elem1366; + for (int _i1367 = 0; _i1367 < _list1365.size; ++_i1367) { - _elem1358 = iprot.readString(); - struct.success.add(_elem1358); + _elem1366 = iprot.readString(); + struct.success.add(_elem1366); } } struct.setSuccessIsSet(true); @@ -151147,13 +151147,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_functions_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1360 = iprot.readListBegin(); - struct.success = new ArrayList(_list1360.size); - String _elem1361; - for (int _i1362 = 0; _i1362 < _list1360.size; ++_i1362) + org.apache.thrift.protocol.TList _list1368 = iprot.readListBegin(); + struct.success = new ArrayList(_list1368.size); + String _elem1369; + for (int _i1370 = 0; _i1370 < _list1368.size; ++_i1370) { - _elem1361 = iprot.readString(); - struct.success.add(_elem1361); + _elem1369 = iprot.readString(); + struct.success.add(_elem1369); } iprot.readListEnd(); } @@ -151188,9 +151188,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_functions_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1363 : struct.success) + for (String _iter1371 : struct.success) { - oprot.writeString(_iter1363); + oprot.writeString(_iter1371); } oprot.writeListEnd(); } @@ -151229,9 +151229,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1364 : struct.success) + for (String _iter1372 : struct.success) { - oprot.writeString(_iter1364); + oprot.writeString(_iter1372); } } } @@ -151246,13 +151246,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_functions_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1365 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1365.size); - String _elem1366; - for (int _i1367 = 0; _i1367 < _list1365.size; ++_i1367) + org.apache.thrift.protocol.TList _list1373 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1373.size); + String _elem1374; + for (int _i1375 = 0; _i1375 < _list1373.size; ++_i1375) { - _elem1366 = iprot.readString(); - struct.success.add(_elem1366); + _elem1374 = iprot.readString(); + struct.success.add(_elem1374); } } struct.setSuccessIsSet(true); @@ -155307,13 +155307,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_role_names_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1368 = iprot.readListBegin(); - struct.success = new ArrayList(_list1368.size); - String _elem1369; - for (int _i1370 = 0; _i1370 < _list1368.size; ++_i1370) + org.apache.thrift.protocol.TList _list1376 = iprot.readListBegin(); + struct.success = new ArrayList(_list1376.size); + String _elem1377; + for (int _i1378 = 0; _i1378 < _list1376.size; ++_i1378) { - _elem1369 = iprot.readString(); - struct.success.add(_elem1369); + _elem1377 = iprot.readString(); + struct.success.add(_elem1377); } iprot.readListEnd(); } @@ -155348,9 +155348,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_role_names_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1371 : struct.success) + for (String _iter1379 : struct.success) { - oprot.writeString(_iter1371); + oprot.writeString(_iter1379); } oprot.writeListEnd(); } @@ -155389,9 +155389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1372 : struct.success) + for (String _iter1380 : struct.success) { - oprot.writeString(_iter1372); + oprot.writeString(_iter1380); } } } @@ -155406,13 +155406,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_role_names_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1373 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1373.size); - String _elem1374; - for (int _i1375 = 0; _i1375 < _list1373.size; ++_i1375) + org.apache.thrift.protocol.TList _list1381 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1381.size); + String _elem1382; + for (int _i1383 = 0; _i1383 < _list1381.size; ++_i1383) { - _elem1374 = iprot.readString(); - struct.success.add(_elem1374); + _elem1382 = iprot.readString(); + struct.success.add(_elem1382); } } struct.setSuccessIsSet(true); @@ -158703,14 +158703,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_roles_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1376 = iprot.readListBegin(); - struct.success = new ArrayList(_list1376.size); - Role _elem1377; - for (int _i1378 = 0; _i1378 < _list1376.size; ++_i1378) + org.apache.thrift.protocol.TList _list1384 = iprot.readListBegin(); + struct.success = new ArrayList(_list1384.size); + Role _elem1385; + for (int _i1386 = 0; _i1386 < _list1384.size; ++_i1386) { - _elem1377 = new Role(); - _elem1377.read(iprot); - struct.success.add(_elem1377); + _elem1385 = new Role(); + _elem1385.read(iprot); + struct.success.add(_elem1385); } iprot.readListEnd(); } @@ -158745,9 +158745,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_roles_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Role _iter1379 : struct.success) + for (Role _iter1387 : struct.success) { - _iter1379.write(oprot); + _iter1387.write(oprot); } oprot.writeListEnd(); } @@ -158786,9 +158786,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter1380 : struct.success) + for (Role _iter1388 : struct.success) { - _iter1380.write(oprot); + _iter1388.write(oprot); } } } @@ -158803,14 +158803,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_roles_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1381 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1381.size); - Role _elem1382; - for (int _i1383 = 0; _i1383 < _list1381.size; ++_i1383) + org.apache.thrift.protocol.TList _list1389 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1389.size); + Role _elem1390; + for (int _i1391 = 0; _i1391 < _list1389.size; ++_i1391) { - _elem1382 = new Role(); - _elem1382.read(iprot); - struct.success.add(_elem1382); + _elem1390 = new Role(); + _elem1390.read(iprot); + struct.success.add(_elem1390); } } struct.setSuccessIsSet(true); @@ -161815,13 +161815,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_privilege_set_a case 3: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1384 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1384.size); - String _elem1385; - for (int _i1386 = 0; _i1386 < _list1384.size; ++_i1386) + org.apache.thrift.protocol.TList _list1392 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1392.size); + String _elem1393; + for (int _i1394 = 0; _i1394 < _list1392.size; ++_i1394) { - _elem1385 = iprot.readString(); - struct.group_names.add(_elem1385); + _elem1393 = iprot.readString(); + struct.group_names.add(_elem1393); } iprot.readListEnd(); } @@ -161857,9 +161857,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_privilege_set_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1387 : struct.group_names) + for (String _iter1395 : struct.group_names) { - oprot.writeString(_iter1387); + oprot.writeString(_iter1395); } oprot.writeListEnd(); } @@ -161902,9 +161902,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_a if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1388 : struct.group_names) + for (String _iter1396 : struct.group_names) { - oprot.writeString(_iter1388); + oprot.writeString(_iter1396); } } } @@ -161925,13 +161925,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1389 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1389.size); - String _elem1390; - for (int _i1391 = 0; _i1391 < _list1389.size; ++_i1391) + org.apache.thrift.protocol.TList _list1397 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1397.size); + String _elem1398; + for (int _i1399 = 0; _i1399 < _list1397.size; ++_i1399) { - _elem1390 = iprot.readString(); - struct.group_names.add(_elem1390); + _elem1398 = iprot.readString(); + struct.group_names.add(_elem1398); } } struct.setGroup_namesIsSet(true); @@ -163389,14 +163389,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_privileges_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1392 = iprot.readListBegin(); - struct.success = new ArrayList(_list1392.size); - HiveObjectPrivilege _elem1393; - for (int _i1394 = 0; _i1394 < _list1392.size; ++_i1394) + org.apache.thrift.protocol.TList _list1400 = iprot.readListBegin(); + struct.success = new ArrayList(_list1400.size); + HiveObjectPrivilege _elem1401; + for (int _i1402 = 0; _i1402 < _list1400.size; ++_i1402) { - _elem1393 = new HiveObjectPrivilege(); - _elem1393.read(iprot); - struct.success.add(_elem1393); + _elem1401 = new HiveObjectPrivilege(); + _elem1401.read(iprot); + struct.success.add(_elem1401); } iprot.readListEnd(); } @@ -163431,9 +163431,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_privileges_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (HiveObjectPrivilege _iter1395 : struct.success) + for (HiveObjectPrivilege _iter1403 : struct.success) { - _iter1395.write(oprot); + _iter1403.write(oprot); } oprot.writeListEnd(); } @@ -163472,9 +163472,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter1396 : struct.success) + for (HiveObjectPrivilege _iter1404 : struct.success) { - _iter1396.write(oprot); + _iter1404.write(oprot); } } } @@ -163489,14 +163489,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_privileges_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1397 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1397.size); - HiveObjectPrivilege _elem1398; - for (int _i1399 = 0; _i1399 < _list1397.size; ++_i1399) + org.apache.thrift.protocol.TList _list1405 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1405.size); + HiveObjectPrivilege _elem1406; + for (int _i1407 = 0; _i1407 < _list1405.size; ++_i1407) { - _elem1398 = new HiveObjectPrivilege(); - _elem1398.read(iprot); - struct.success.add(_elem1398); + _elem1406 = new HiveObjectPrivilege(); + _elem1406.read(iprot); + struct.success.add(_elem1406); } } struct.setSuccessIsSet(true); @@ -166398,13 +166398,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_args struct case 2: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1400 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1400.size); - String _elem1401; - for (int _i1402 = 0; _i1402 < _list1400.size; ++_i1402) + org.apache.thrift.protocol.TList _list1408 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1408.size); + String _elem1409; + for (int _i1410 = 0; _i1410 < _list1408.size; ++_i1410) { - _elem1401 = iprot.readString(); - struct.group_names.add(_elem1401); + _elem1409 = iprot.readString(); + struct.group_names.add(_elem1409); } iprot.readListEnd(); } @@ -166435,9 +166435,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_args struc oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1403 : struct.group_names) + for (String _iter1411 : struct.group_names) { - oprot.writeString(_iter1403); + oprot.writeString(_iter1411); } oprot.writeListEnd(); } @@ -166474,9 +166474,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1404 : struct.group_names) + for (String _iter1412 : struct.group_names) { - oprot.writeString(_iter1404); + oprot.writeString(_iter1412); } } } @@ -166492,13 +166492,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1405 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1405.size); - String _elem1406; - for (int _i1407 = 0; _i1407 < _list1405.size; ++_i1407) + org.apache.thrift.protocol.TList _list1413 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1413.size); + String _elem1414; + for (int _i1415 = 0; _i1415 < _list1413.size; ++_i1415) { - _elem1406 = iprot.readString(); - struct.group_names.add(_elem1406); + _elem1414 = iprot.readString(); + struct.group_names.add(_elem1414); } } struct.setGroup_namesIsSet(true); @@ -166901,13 +166901,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_result stru case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1408 = iprot.readListBegin(); - struct.success = new ArrayList(_list1408.size); - String _elem1409; - for (int _i1410 = 0; _i1410 < _list1408.size; ++_i1410) + org.apache.thrift.protocol.TList _list1416 = iprot.readListBegin(); + struct.success = new ArrayList(_list1416.size); + String _elem1417; + for (int _i1418 = 0; _i1418 < _list1416.size; ++_i1418) { - _elem1409 = iprot.readString(); - struct.success.add(_elem1409); + _elem1417 = iprot.readString(); + struct.success.add(_elem1417); } iprot.readListEnd(); } @@ -166942,9 +166942,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_result str oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1411 : struct.success) + for (String _iter1419 : struct.success) { - oprot.writeString(_iter1411); + oprot.writeString(_iter1419); } oprot.writeListEnd(); } @@ -166983,9 +166983,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1412 : struct.success) + for (String _iter1420 : struct.success) { - oprot.writeString(_iter1412); + oprot.writeString(_iter1420); } } } @@ -167000,13 +167000,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_result struc BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1413 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1413.size); - String _elem1414; - for (int _i1415 = 0; _i1415 < _list1413.size; ++_i1415) + org.apache.thrift.protocol.TList _list1421 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1421.size); + String _elem1422; + for (int _i1423 = 0; _i1423 < _list1421.size; ++_i1423) { - _elem1414 = iprot.readString(); - struct.success.add(_elem1414); + _elem1422 = iprot.readString(); + struct.success.add(_elem1422); } } struct.setSuccessIsSet(true); @@ -172297,13 +172297,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_token_ident case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1416 = iprot.readListBegin(); - struct.success = new ArrayList(_list1416.size); - String _elem1417; - for (int _i1418 = 0; _i1418 < _list1416.size; ++_i1418) + org.apache.thrift.protocol.TList _list1424 = iprot.readListBegin(); + struct.success = new ArrayList(_list1424.size); + String _elem1425; + for (int _i1426 = 0; _i1426 < _list1424.size; ++_i1426) { - _elem1417 = iprot.readString(); - struct.success.add(_elem1417); + _elem1425 = iprot.readString(); + struct.success.add(_elem1425); } iprot.readListEnd(); } @@ -172329,9 +172329,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_token_iden oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1419 : struct.success) + for (String _iter1427 : struct.success) { - oprot.writeString(_iter1419); + oprot.writeString(_iter1427); } oprot.writeListEnd(); } @@ -172362,9 +172362,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_token_ident if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1420 : struct.success) + for (String _iter1428 : struct.success) { - oprot.writeString(_iter1420); + oprot.writeString(_iter1428); } } } @@ -172376,13 +172376,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_token_identi BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1421 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1421.size); - String _elem1422; - for (int _i1423 = 0; _i1423 < _list1421.size; ++_i1423) + org.apache.thrift.protocol.TList _list1429 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1429.size); + String _elem1430; + for (int _i1431 = 0; _i1431 < _list1429.size; ++_i1431) { - _elem1422 = iprot.readString(); - struct.success.add(_elem1422); + _elem1430 = iprot.readString(); + struct.success.add(_elem1430); } } struct.setSuccessIsSet(true); @@ -175412,13 +175412,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_master_keys_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1424 = iprot.readListBegin(); - struct.success = new ArrayList(_list1424.size); - String _elem1425; - for (int _i1426 = 0; _i1426 < _list1424.size; ++_i1426) + org.apache.thrift.protocol.TList _list1432 = iprot.readListBegin(); + struct.success = new ArrayList(_list1432.size); + String _elem1433; + for (int _i1434 = 0; _i1434 < _list1432.size; ++_i1434) { - _elem1425 = iprot.readString(); - struct.success.add(_elem1425); + _elem1433 = iprot.readString(); + struct.success.add(_elem1433); } iprot.readListEnd(); } @@ -175444,9 +175444,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_master_keys_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1427 : struct.success) + for (String _iter1435 : struct.success) { - oprot.writeString(_iter1427); + oprot.writeString(_iter1435); } oprot.writeListEnd(); } @@ -175477,9 +175477,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_master_keys_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1428 : struct.success) + for (String _iter1436 : struct.success) { - oprot.writeString(_iter1428); + oprot.writeString(_iter1436); } } } @@ -175491,13 +175491,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_master_keys_resu BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1429 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1429.size); - String _elem1430; - for (int _i1431 = 0; _i1431 < _list1429.size; ++_i1431) + org.apache.thrift.protocol.TList _list1437 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1437.size); + String _elem1438; + for (int _i1439 = 0; _i1439 < _list1437.size; ++_i1439) { - _elem1430 = iprot.readString(); - struct.success.add(_elem1430); + _elem1438 = iprot.readString(); + struct.success.add(_elem1438); } } struct.setSuccessIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMFullResourcePlan.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMFullResourcePlan.java index 9c05a18123..db14cff18e 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMFullResourcePlan.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMFullResourcePlan.java @@ -755,14 +755,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMFullResourcePlan case 2: // POOLS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list794 = iprot.readListBegin(); - struct.pools = new ArrayList(_list794.size); - WMPool _elem795; - for (int _i796 = 0; _i796 < _list794.size; ++_i796) + org.apache.thrift.protocol.TList _list802 = iprot.readListBegin(); + struct.pools = new ArrayList(_list802.size); + WMPool _elem803; + for (int _i804 = 0; _i804 < _list802.size; ++_i804) { - _elem795 = new WMPool(); - _elem795.read(iprot); - struct.pools.add(_elem795); + _elem803 = new WMPool(); + _elem803.read(iprot); + struct.pools.add(_elem803); } iprot.readListEnd(); } @@ -774,14 +774,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMFullResourcePlan case 3: // MAPPINGS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list797 = iprot.readListBegin(); - struct.mappings = new ArrayList(_list797.size); - WMMapping _elem798; - for (int _i799 = 0; _i799 < _list797.size; ++_i799) + org.apache.thrift.protocol.TList _list805 = iprot.readListBegin(); + struct.mappings = new ArrayList(_list805.size); + WMMapping _elem806; + for (int _i807 = 0; _i807 < _list805.size; ++_i807) { - _elem798 = new WMMapping(); - _elem798.read(iprot); - struct.mappings.add(_elem798); + _elem806 = new WMMapping(); + _elem806.read(iprot); + struct.mappings.add(_elem806); } iprot.readListEnd(); } @@ -793,14 +793,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMFullResourcePlan case 4: // TRIGGERS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list800 = iprot.readListBegin(); - struct.triggers = new ArrayList(_list800.size); - WMTrigger _elem801; - for (int _i802 = 0; _i802 < _list800.size; ++_i802) + org.apache.thrift.protocol.TList _list808 = iprot.readListBegin(); + struct.triggers = new ArrayList(_list808.size); + WMTrigger _elem809; + for (int _i810 = 0; _i810 < _list808.size; ++_i810) { - _elem801 = new WMTrigger(); - _elem801.read(iprot); - struct.triggers.add(_elem801); + _elem809 = new WMTrigger(); + _elem809.read(iprot); + struct.triggers.add(_elem809); } iprot.readListEnd(); } @@ -812,14 +812,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMFullResourcePlan case 5: // POOL_TRIGGERS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list803 = iprot.readListBegin(); - struct.poolTriggers = new ArrayList(_list803.size); - WMPoolTrigger _elem804; - for (int _i805 = 0; _i805 < _list803.size; ++_i805) + org.apache.thrift.protocol.TList _list811 = iprot.readListBegin(); + struct.poolTriggers = new ArrayList(_list811.size); + WMPoolTrigger _elem812; + for (int _i813 = 0; _i813 < _list811.size; ++_i813) { - _elem804 = new WMPoolTrigger(); - _elem804.read(iprot); - struct.poolTriggers.add(_elem804); + _elem812 = new WMPoolTrigger(); + _elem812.read(iprot); + struct.poolTriggers.add(_elem812); } iprot.readListEnd(); } @@ -850,9 +850,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMFullResourcePlan oprot.writeFieldBegin(POOLS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.pools.size())); - for (WMPool _iter806 : struct.pools) + for (WMPool _iter814 : struct.pools) { - _iter806.write(oprot); + _iter814.write(oprot); } oprot.writeListEnd(); } @@ -863,9 +863,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMFullResourcePlan oprot.writeFieldBegin(MAPPINGS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mappings.size())); - for (WMMapping _iter807 : struct.mappings) + for (WMMapping _iter815 : struct.mappings) { - _iter807.write(oprot); + _iter815.write(oprot); } oprot.writeListEnd(); } @@ -877,9 +877,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMFullResourcePlan oprot.writeFieldBegin(TRIGGERS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.triggers.size())); - for (WMTrigger _iter808 : struct.triggers) + for (WMTrigger _iter816 : struct.triggers) { - _iter808.write(oprot); + _iter816.write(oprot); } oprot.writeListEnd(); } @@ -891,9 +891,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMFullResourcePlan oprot.writeFieldBegin(POOL_TRIGGERS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.poolTriggers.size())); - for (WMPoolTrigger _iter809 : struct.poolTriggers) + for (WMPoolTrigger _iter817 : struct.poolTriggers) { - _iter809.write(oprot); + _iter817.write(oprot); } oprot.writeListEnd(); } @@ -920,9 +920,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMFullResourcePlan struct.plan.write(oprot); { oprot.writeI32(struct.pools.size()); - for (WMPool _iter810 : struct.pools) + for (WMPool _iter818 : struct.pools) { - _iter810.write(oprot); + _iter818.write(oprot); } } BitSet optionals = new BitSet(); @@ -939,27 +939,27 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMFullResourcePlan if (struct.isSetMappings()) { { oprot.writeI32(struct.mappings.size()); - for (WMMapping _iter811 : struct.mappings) + for (WMMapping _iter819 : struct.mappings) { - _iter811.write(oprot); + _iter819.write(oprot); } } } if (struct.isSetTriggers()) { { oprot.writeI32(struct.triggers.size()); - for (WMTrigger _iter812 : struct.triggers) + for (WMTrigger _iter820 : struct.triggers) { - _iter812.write(oprot); + _iter820.write(oprot); } } } if (struct.isSetPoolTriggers()) { { oprot.writeI32(struct.poolTriggers.size()); - for (WMPoolTrigger _iter813 : struct.poolTriggers) + for (WMPoolTrigger _iter821 : struct.poolTriggers) { - _iter813.write(oprot); + _iter821.write(oprot); } } } @@ -972,56 +972,56 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMFullResourcePlan s struct.plan.read(iprot); struct.setPlanIsSet(true); { - org.apache.thrift.protocol.TList _list814 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.pools = new ArrayList(_list814.size); - WMPool _elem815; - for (int _i816 = 0; _i816 < _list814.size; ++_i816) + org.apache.thrift.protocol.TList _list822 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.pools = new ArrayList(_list822.size); + WMPool _elem823; + for (int _i824 = 0; _i824 < _list822.size; ++_i824) { - _elem815 = new WMPool(); - _elem815.read(iprot); - struct.pools.add(_elem815); + _elem823 = new WMPool(); + _elem823.read(iprot); + struct.pools.add(_elem823); } } struct.setPoolsIsSet(true); BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list817 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.mappings = new ArrayList(_list817.size); - WMMapping _elem818; - for (int _i819 = 0; _i819 < _list817.size; ++_i819) + org.apache.thrift.protocol.TList _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.mappings = new ArrayList(_list825.size); + WMMapping _elem826; + for (int _i827 = 0; _i827 < _list825.size; ++_i827) { - _elem818 = new WMMapping(); - _elem818.read(iprot); - struct.mappings.add(_elem818); + _elem826 = new WMMapping(); + _elem826.read(iprot); + struct.mappings.add(_elem826); } } struct.setMappingsIsSet(true); } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list820 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.triggers = new ArrayList(_list820.size); - WMTrigger _elem821; - for (int _i822 = 0; _i822 < _list820.size; ++_i822) + org.apache.thrift.protocol.TList _list828 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.triggers = new ArrayList(_list828.size); + WMTrigger _elem829; + for (int _i830 = 0; _i830 < _list828.size; ++_i830) { - _elem821 = new WMTrigger(); - _elem821.read(iprot); - struct.triggers.add(_elem821); + _elem829 = new WMTrigger(); + _elem829.read(iprot); + struct.triggers.add(_elem829); } } struct.setTriggersIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list823 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.poolTriggers = new ArrayList(_list823.size); - WMPoolTrigger _elem824; - for (int _i825 = 0; _i825 < _list823.size; ++_i825) + org.apache.thrift.protocol.TList _list831 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.poolTriggers = new ArrayList(_list831.size); + WMPoolTrigger _elem832; + for (int _i833 = 0; _i833 < _list831.size; ++_i833) { - _elem824 = new WMPoolTrigger(); - _elem824.read(iprot); - struct.poolTriggers.add(_elem824); + _elem832 = new WMPoolTrigger(); + _elem832.read(iprot); + struct.poolTriggers.add(_elem832); } } struct.setPoolTriggersIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java index ba44e3ac21..171b2affab 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java @@ -346,14 +346,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMGetAllResourcePla case 1: // RESOURCE_PLANS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list826 = iprot.readListBegin(); - struct.resourcePlans = new ArrayList(_list826.size); - WMResourcePlan _elem827; - for (int _i828 = 0; _i828 < _list826.size; ++_i828) + org.apache.thrift.protocol.TList _list834 = iprot.readListBegin(); + struct.resourcePlans = new ArrayList(_list834.size); + WMResourcePlan _elem835; + for (int _i836 = 0; _i836 < _list834.size; ++_i836) { - _elem827 = new WMResourcePlan(); - _elem827.read(iprot); - struct.resourcePlans.add(_elem827); + _elem835 = new WMResourcePlan(); + _elem835.read(iprot); + struct.resourcePlans.add(_elem835); } iprot.readListEnd(); } @@ -380,9 +380,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMGetAllResourcePl oprot.writeFieldBegin(RESOURCE_PLANS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.resourcePlans.size())); - for (WMResourcePlan _iter829 : struct.resourcePlans) + for (WMResourcePlan _iter837 : struct.resourcePlans) { - _iter829.write(oprot); + _iter837.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMGetAllResourcePla if (struct.isSetResourcePlans()) { { oprot.writeI32(struct.resourcePlans.size()); - for (WMResourcePlan _iter830 : struct.resourcePlans) + for (WMResourcePlan _iter838 : struct.resourcePlans) { - _iter830.write(oprot); + _iter838.write(oprot); } } } @@ -428,14 +428,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMGetAllResourcePlan BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list831 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.resourcePlans = new ArrayList(_list831.size); - WMResourcePlan _elem832; - for (int _i833 = 0; _i833 < _list831.size; ++_i833) + org.apache.thrift.protocol.TList _list839 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.resourcePlans = new ArrayList(_list839.size); + WMResourcePlan _elem840; + for (int _i841 = 0; _i841 < _list839.size; ++_i841) { - _elem832 = new WMResourcePlan(); - _elem832.read(iprot); - struct.resourcePlans.add(_elem832); + _elem840 = new WMResourcePlan(); + _elem840.read(iprot); + struct.resourcePlans.add(_elem840); } } struct.setResourcePlansIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java index edec382d19..a1d4c372b1 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java @@ -346,14 +346,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMGetTriggersForRes case 1: // TRIGGERS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list850 = iprot.readListBegin(); - struct.triggers = new ArrayList(_list850.size); - WMTrigger _elem851; - for (int _i852 = 0; _i852 < _list850.size; ++_i852) + org.apache.thrift.protocol.TList _list858 = iprot.readListBegin(); + struct.triggers = new ArrayList(_list858.size); + WMTrigger _elem859; + for (int _i860 = 0; _i860 < _list858.size; ++_i860) { - _elem851 = new WMTrigger(); - _elem851.read(iprot); - struct.triggers.add(_elem851); + _elem859 = new WMTrigger(); + _elem859.read(iprot); + struct.triggers.add(_elem859); } iprot.readListEnd(); } @@ -380,9 +380,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMGetTriggersForRe oprot.writeFieldBegin(TRIGGERS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.triggers.size())); - for (WMTrigger _iter853 : struct.triggers) + for (WMTrigger _iter861 : struct.triggers) { - _iter853.write(oprot); + _iter861.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForRes if (struct.isSetTriggers()) { { oprot.writeI32(struct.triggers.size()); - for (WMTrigger _iter854 : struct.triggers) + for (WMTrigger _iter862 : struct.triggers) { - _iter854.write(oprot); + _iter862.write(oprot); } } } @@ -428,14 +428,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForReso BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list855 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.triggers = new ArrayList(_list855.size); - WMTrigger _elem856; - for (int _i857 = 0; _i857 < _list855.size; ++_i857) + org.apache.thrift.protocol.TList _list863 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.triggers = new ArrayList(_list863.size); + WMTrigger _elem864; + for (int _i865 = 0; _i865 < _list863.size; ++_i865) { - _elem856 = new WMTrigger(); - _elem856.read(iprot); - struct.triggers.add(_elem856); + _elem864 = new WMTrigger(); + _elem864.read(iprot); + struct.triggers.add(_elem864); } } struct.setTriggersIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java index 228f37f725..070fcfff20 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java @@ -441,13 +441,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMValidateResourceP case 1: // ERRORS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list834 = iprot.readListBegin(); - struct.errors = new ArrayList(_list834.size); - String _elem835; - for (int _i836 = 0; _i836 < _list834.size; ++_i836) + org.apache.thrift.protocol.TList _list842 = iprot.readListBegin(); + struct.errors = new ArrayList(_list842.size); + String _elem843; + for (int _i844 = 0; _i844 < _list842.size; ++_i844) { - _elem835 = iprot.readString(); - struct.errors.add(_elem835); + _elem843 = iprot.readString(); + struct.errors.add(_elem843); } iprot.readListEnd(); } @@ -459,13 +459,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMValidateResourceP case 2: // WARNINGS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list837 = iprot.readListBegin(); - struct.warnings = new ArrayList(_list837.size); - String _elem838; - for (int _i839 = 0; _i839 < _list837.size; ++_i839) + org.apache.thrift.protocol.TList _list845 = iprot.readListBegin(); + struct.warnings = new ArrayList(_list845.size); + String _elem846; + for (int _i847 = 0; _i847 < _list845.size; ++_i847) { - _elem838 = iprot.readString(); - struct.warnings.add(_elem838); + _elem846 = iprot.readString(); + struct.warnings.add(_elem846); } iprot.readListEnd(); } @@ -492,9 +492,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMValidateResource oprot.writeFieldBegin(ERRORS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.errors.size())); - for (String _iter840 : struct.errors) + for (String _iter848 : struct.errors) { - oprot.writeString(_iter840); + oprot.writeString(_iter848); } oprot.writeListEnd(); } @@ -506,9 +506,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMValidateResource oprot.writeFieldBegin(WARNINGS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.warnings.size())); - for (String _iter841 : struct.warnings) + for (String _iter849 : struct.warnings) { - oprot.writeString(_iter841); + oprot.writeString(_iter849); } oprot.writeListEnd(); } @@ -543,18 +543,18 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMValidateResourceP if (struct.isSetErrors()) { { oprot.writeI32(struct.errors.size()); - for (String _iter842 : struct.errors) + for (String _iter850 : struct.errors) { - oprot.writeString(_iter842); + oprot.writeString(_iter850); } } } if (struct.isSetWarnings()) { { oprot.writeI32(struct.warnings.size()); - for (String _iter843 : struct.warnings) + for (String _iter851 : struct.warnings) { - oprot.writeString(_iter843); + oprot.writeString(_iter851); } } } @@ -566,26 +566,26 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMValidateResourcePl BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list844 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.errors = new ArrayList(_list844.size); - String _elem845; - for (int _i846 = 0; _i846 < _list844.size; ++_i846) + org.apache.thrift.protocol.TList _list852 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.errors = new ArrayList(_list852.size); + String _elem853; + for (int _i854 = 0; _i854 < _list852.size; ++_i854) { - _elem845 = iprot.readString(); - struct.errors.add(_elem845); + _elem853 = iprot.readString(); + struct.errors.add(_elem853); } } struct.setErrorsIsSet(true); } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list847 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.warnings = new ArrayList(_list847.size); - String _elem848; - for (int _i849 = 0; _i849 < _list847.size; ++_i849) + org.apache.thrift.protocol.TList _list855 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.warnings = new ArrayList(_list855.size); + String _elem856; + for (int _i857 = 0; _i857 < _list855.size; ++_i857) { - _elem848 = iprot.readString(); - struct.warnings.add(_elem848); + _elem856 = iprot.readString(); + struct.warnings.add(_elem856); } } struct.setWarningsIsSet(true); diff --git a/standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index d063de853c..de33428820 100644 --- a/standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -13064,14 +13064,14 @@ class ThriftHiveMetastore_get_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size759 = 0; - $_etype762 = 0; - $xfer += $input->readListBegin($_etype762, $_size759); - for ($_i763 = 0; $_i763 < $_size759; ++$_i763) + $_size766 = 0; + $_etype769 = 0; + $xfer += $input->readListBegin($_etype769, $_size766); + for ($_i770 = 0; $_i770 < $_size766; ++$_i770) { - $elem764 = null; - $xfer += $input->readString($elem764); - $this->success []= $elem764; + $elem771 = null; + $xfer += $input->readString($elem771); + $this->success []= $elem771; } $xfer += $input->readListEnd(); } else { @@ -13107,9 +13107,9 @@ class ThriftHiveMetastore_get_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter765) + foreach ($this->success as $iter772) { - $xfer += $output->writeString($iter765); + $xfer += $output->writeString($iter772); } } $output->writeListEnd(); @@ -13240,14 +13240,14 @@ class ThriftHiveMetastore_get_all_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size766 = 0; - $_etype769 = 0; - $xfer += $input->readListBegin($_etype769, $_size766); - for ($_i770 = 0; $_i770 < $_size766; ++$_i770) + $_size773 = 0; + $_etype776 = 0; + $xfer += $input->readListBegin($_etype776, $_size773); + for ($_i777 = 0; $_i777 < $_size773; ++$_i777) { - $elem771 = null; - $xfer += $input->readString($elem771); - $this->success []= $elem771; + $elem778 = null; + $xfer += $input->readString($elem778); + $this->success []= $elem778; } $xfer += $input->readListEnd(); } else { @@ -13283,9 +13283,9 @@ class ThriftHiveMetastore_get_all_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter772) + foreach ($this->success as $iter779) { - $xfer += $output->writeString($iter772); + $xfer += $output->writeString($iter779); } } $output->writeListEnd(); @@ -14286,18 +14286,18 @@ class ThriftHiveMetastore_get_type_all_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size773 = 0; - $_ktype774 = 0; - $_vtype775 = 0; - $xfer += $input->readMapBegin($_ktype774, $_vtype775, $_size773); - for ($_i777 = 0; $_i777 < $_size773; ++$_i777) + $_size780 = 0; + $_ktype781 = 0; + $_vtype782 = 0; + $xfer += $input->readMapBegin($_ktype781, $_vtype782, $_size780); + for ($_i784 = 0; $_i784 < $_size780; ++$_i784) { - $key778 = ''; - $val779 = new \metastore\Type(); - $xfer += $input->readString($key778); - $val779 = new \metastore\Type(); - $xfer += $val779->read($input); - $this->success[$key778] = $val779; + $key785 = ''; + $val786 = new \metastore\Type(); + $xfer += $input->readString($key785); + $val786 = new \metastore\Type(); + $xfer += $val786->read($input); + $this->success[$key785] = $val786; } $xfer += $input->readMapEnd(); } else { @@ -14333,10 +14333,10 @@ class ThriftHiveMetastore_get_type_all_result { { $output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->success)); { - foreach ($this->success as $kiter780 => $viter781) + foreach ($this->success as $kiter787 => $viter788) { - $xfer += $output->writeString($kiter780); - $xfer += $viter781->write($output); + $xfer += $output->writeString($kiter787); + $xfer += $viter788->write($output); } } $output->writeMapEnd(); @@ -14540,15 +14540,15 @@ class ThriftHiveMetastore_get_fields_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size782 = 0; - $_etype785 = 0; - $xfer += $input->readListBegin($_etype785, $_size782); - for ($_i786 = 0; $_i786 < $_size782; ++$_i786) + $_size789 = 0; + $_etype792 = 0; + $xfer += $input->readListBegin($_etype792, $_size789); + for ($_i793 = 0; $_i793 < $_size789; ++$_i793) { - $elem787 = null; - $elem787 = new \metastore\FieldSchema(); - $xfer += $elem787->read($input); - $this->success []= $elem787; + $elem794 = null; + $elem794 = new \metastore\FieldSchema(); + $xfer += $elem794->read($input); + $this->success []= $elem794; } $xfer += $input->readListEnd(); } else { @@ -14600,9 +14600,9 @@ class ThriftHiveMetastore_get_fields_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter788) + foreach ($this->success as $iter795) { - $xfer += $iter788->write($output); + $xfer += $iter795->write($output); } } $output->writeListEnd(); @@ -14844,15 +14844,15 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size789 = 0; - $_etype792 = 0; - $xfer += $input->readListBegin($_etype792, $_size789); - for ($_i793 = 0; $_i793 < $_size789; ++$_i793) + $_size796 = 0; + $_etype799 = 0; + $xfer += $input->readListBegin($_etype799, $_size796); + for ($_i800 = 0; $_i800 < $_size796; ++$_i800) { - $elem794 = null; - $elem794 = new \metastore\FieldSchema(); - $xfer += $elem794->read($input); - $this->success []= $elem794; + $elem801 = null; + $elem801 = new \metastore\FieldSchema(); + $xfer += $elem801->read($input); + $this->success []= $elem801; } $xfer += $input->readListEnd(); } else { @@ -14904,9 +14904,9 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter795) + foreach ($this->success as $iter802) { - $xfer += $iter795->write($output); + $xfer += $iter802->write($output); } } $output->writeListEnd(); @@ -15120,15 +15120,15 @@ class ThriftHiveMetastore_get_schema_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size796 = 0; - $_etype799 = 0; - $xfer += $input->readListBegin($_etype799, $_size796); - for ($_i800 = 0; $_i800 < $_size796; ++$_i800) + $_size803 = 0; + $_etype806 = 0; + $xfer += $input->readListBegin($_etype806, $_size803); + for ($_i807 = 0; $_i807 < $_size803; ++$_i807) { - $elem801 = null; - $elem801 = new \metastore\FieldSchema(); - $xfer += $elem801->read($input); - $this->success []= $elem801; + $elem808 = null; + $elem808 = new \metastore\FieldSchema(); + $xfer += $elem808->read($input); + $this->success []= $elem808; } $xfer += $input->readListEnd(); } else { @@ -15180,9 +15180,9 @@ class ThriftHiveMetastore_get_schema_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter802) + foreach ($this->success as $iter809) { - $xfer += $iter802->write($output); + $xfer += $iter809->write($output); } } $output->writeListEnd(); @@ -15424,15 +15424,15 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size803 = 0; - $_etype806 = 0; - $xfer += $input->readListBegin($_etype806, $_size803); - for ($_i807 = 0; $_i807 < $_size803; ++$_i807) + $_size810 = 0; + $_etype813 = 0; + $xfer += $input->readListBegin($_etype813, $_size810); + for ($_i814 = 0; $_i814 < $_size810; ++$_i814) { - $elem808 = null; - $elem808 = new \metastore\FieldSchema(); - $xfer += $elem808->read($input); - $this->success []= $elem808; + $elem815 = null; + $elem815 = new \metastore\FieldSchema(); + $xfer += $elem815->read($input); + $this->success []= $elem815; } $xfer += $input->readListEnd(); } else { @@ -15484,9 +15484,9 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter809) + foreach ($this->success as $iter816) { - $xfer += $iter809->write($output); + $xfer += $iter816->write($output); } } $output->writeListEnd(); @@ -16126,15 +16126,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 2: if ($ftype == TType::LST) { $this->primaryKeys = array(); - $_size810 = 0; - $_etype813 = 0; - $xfer += $input->readListBegin($_etype813, $_size810); - for ($_i814 = 0; $_i814 < $_size810; ++$_i814) + $_size817 = 0; + $_etype820 = 0; + $xfer += $input->readListBegin($_etype820, $_size817); + for ($_i821 = 0; $_i821 < $_size817; ++$_i821) { - $elem815 = null; - $elem815 = new \metastore\SQLPrimaryKey(); - $xfer += $elem815->read($input); - $this->primaryKeys []= $elem815; + $elem822 = null; + $elem822 = new \metastore\SQLPrimaryKey(); + $xfer += $elem822->read($input); + $this->primaryKeys []= $elem822; } $xfer += $input->readListEnd(); } else { @@ -16144,15 +16144,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 3: if ($ftype == TType::LST) { $this->foreignKeys = array(); - $_size816 = 0; - $_etype819 = 0; - $xfer += $input->readListBegin($_etype819, $_size816); - for ($_i820 = 0; $_i820 < $_size816; ++$_i820) + $_size823 = 0; + $_etype826 = 0; + $xfer += $input->readListBegin($_etype826, $_size823); + for ($_i827 = 0; $_i827 < $_size823; ++$_i827) { - $elem821 = null; - $elem821 = new \metastore\SQLForeignKey(); - $xfer += $elem821->read($input); - $this->foreignKeys []= $elem821; + $elem828 = null; + $elem828 = new \metastore\SQLForeignKey(); + $xfer += $elem828->read($input); + $this->foreignKeys []= $elem828; } $xfer += $input->readListEnd(); } else { @@ -16162,15 +16162,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 4: if ($ftype == TType::LST) { $this->uniqueConstraints = array(); - $_size822 = 0; - $_etype825 = 0; - $xfer += $input->readListBegin($_etype825, $_size822); - for ($_i826 = 0; $_i826 < $_size822; ++$_i826) + $_size829 = 0; + $_etype832 = 0; + $xfer += $input->readListBegin($_etype832, $_size829); + for ($_i833 = 0; $_i833 < $_size829; ++$_i833) { - $elem827 = null; - $elem827 = new \metastore\SQLUniqueConstraint(); - $xfer += $elem827->read($input); - $this->uniqueConstraints []= $elem827; + $elem834 = null; + $elem834 = new \metastore\SQLUniqueConstraint(); + $xfer += $elem834->read($input); + $this->uniqueConstraints []= $elem834; } $xfer += $input->readListEnd(); } else { @@ -16180,15 +16180,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 5: if ($ftype == TType::LST) { $this->notNullConstraints = array(); - $_size828 = 0; - $_etype831 = 0; - $xfer += $input->readListBegin($_etype831, $_size828); - for ($_i832 = 0; $_i832 < $_size828; ++$_i832) + $_size835 = 0; + $_etype838 = 0; + $xfer += $input->readListBegin($_etype838, $_size835); + for ($_i839 = 0; $_i839 < $_size835; ++$_i839) { - $elem833 = null; - $elem833 = new \metastore\SQLNotNullConstraint(); - $xfer += $elem833->read($input); - $this->notNullConstraints []= $elem833; + $elem840 = null; + $elem840 = new \metastore\SQLNotNullConstraint(); + $xfer += $elem840->read($input); + $this->notNullConstraints []= $elem840; } $xfer += $input->readListEnd(); } else { @@ -16224,9 +16224,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->primaryKeys)); { - foreach ($this->primaryKeys as $iter834) + foreach ($this->primaryKeys as $iter841) { - $xfer += $iter834->write($output); + $xfer += $iter841->write($output); } } $output->writeListEnd(); @@ -16241,9 +16241,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->foreignKeys)); { - foreach ($this->foreignKeys as $iter835) + foreach ($this->foreignKeys as $iter842) { - $xfer += $iter835->write($output); + $xfer += $iter842->write($output); } } $output->writeListEnd(); @@ -16258,9 +16258,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->uniqueConstraints)); { - foreach ($this->uniqueConstraints as $iter836) + foreach ($this->uniqueConstraints as $iter843) { - $xfer += $iter836->write($output); + $xfer += $iter843->write($output); } } $output->writeListEnd(); @@ -16275,9 +16275,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->notNullConstraints)); { - foreach ($this->notNullConstraints as $iter837) + foreach ($this->notNullConstraints as $iter844) { - $xfer += $iter837->write($output); + $xfer += $iter844->write($output); } } $output->writeListEnd(); @@ -17913,14 +17913,14 @@ class ThriftHiveMetastore_truncate_table_args { case 3: if ($ftype == TType::LST) { $this->partNames = array(); - $_size838 = 0; - $_etype841 = 0; - $xfer += $input->readListBegin($_etype841, $_size838); - for ($_i842 = 0; $_i842 < $_size838; ++$_i842) + $_size845 = 0; + $_etype848 = 0; + $xfer += $input->readListBegin($_etype848, $_size845); + for ($_i849 = 0; $_i849 < $_size845; ++$_i849) { - $elem843 = null; - $xfer += $input->readString($elem843); - $this->partNames []= $elem843; + $elem850 = null; + $xfer += $input->readString($elem850); + $this->partNames []= $elem850; } $xfer += $input->readListEnd(); } else { @@ -17958,9 +17958,9 @@ class ThriftHiveMetastore_truncate_table_args { { $output->writeListBegin(TType::STRING, count($this->partNames)); { - foreach ($this->partNames as $iter844) + foreach ($this->partNames as $iter851) { - $xfer += $output->writeString($iter844); + $xfer += $output->writeString($iter851); } } $output->writeListEnd(); @@ -18211,14 +18211,14 @@ class ThriftHiveMetastore_get_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size845 = 0; - $_etype848 = 0; - $xfer += $input->readListBegin($_etype848, $_size845); - for ($_i849 = 0; $_i849 < $_size845; ++$_i849) + $_size852 = 0; + $_etype855 = 0; + $xfer += $input->readListBegin($_etype855, $_size852); + for ($_i856 = 0; $_i856 < $_size852; ++$_i856) { - $elem850 = null; - $xfer += $input->readString($elem850); - $this->success []= $elem850; + $elem857 = null; + $xfer += $input->readString($elem857); + $this->success []= $elem857; } $xfer += $input->readListEnd(); } else { @@ -18254,9 +18254,9 @@ class ThriftHiveMetastore_get_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter851) + foreach ($this->success as $iter858) { - $xfer += $output->writeString($iter851); + $xfer += $output->writeString($iter858); } } $output->writeListEnd(); @@ -18458,14 +18458,14 @@ class ThriftHiveMetastore_get_tables_by_type_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size852 = 0; - $_etype855 = 0; - $xfer += $input->readListBegin($_etype855, $_size852); - for ($_i856 = 0; $_i856 < $_size852; ++$_i856) + $_size859 = 0; + $_etype862 = 0; + $xfer += $input->readListBegin($_etype862, $_size859); + for ($_i863 = 0; $_i863 < $_size859; ++$_i863) { - $elem857 = null; - $xfer += $input->readString($elem857); - $this->success []= $elem857; + $elem864 = null; + $xfer += $input->readString($elem864); + $this->success []= $elem864; } $xfer += $input->readListEnd(); } else { @@ -18501,9 +18501,9 @@ class ThriftHiveMetastore_get_tables_by_type_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter858) + foreach ($this->success as $iter865) { - $xfer += $output->writeString($iter858); + $xfer += $output->writeString($iter865); } } $output->writeListEnd(); @@ -18659,14 +18659,14 @@ class ThriftHiveMetastore_get_materialized_views_for_rewriting_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size859 = 0; - $_etype862 = 0; - $xfer += $input->readListBegin($_etype862, $_size859); - for ($_i863 = 0; $_i863 < $_size859; ++$_i863) + $_size866 = 0; + $_etype869 = 0; + $xfer += $input->readListBegin($_etype869, $_size866); + for ($_i870 = 0; $_i870 < $_size866; ++$_i870) { - $elem864 = null; - $xfer += $input->readString($elem864); - $this->success []= $elem864; + $elem871 = null; + $xfer += $input->readString($elem871); + $this->success []= $elem871; } $xfer += $input->readListEnd(); } else { @@ -18702,9 +18702,9 @@ class ThriftHiveMetastore_get_materialized_views_for_rewriting_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter865) + foreach ($this->success as $iter872) { - $xfer += $output->writeString($iter865); + $xfer += $output->writeString($iter872); } } $output->writeListEnd(); @@ -18809,14 +18809,14 @@ class ThriftHiveMetastore_get_table_meta_args { case 3: if ($ftype == TType::LST) { $this->tbl_types = array(); - $_size866 = 0; - $_etype869 = 0; - $xfer += $input->readListBegin($_etype869, $_size866); - for ($_i870 = 0; $_i870 < $_size866; ++$_i870) + $_size873 = 0; + $_etype876 = 0; + $xfer += $input->readListBegin($_etype876, $_size873); + for ($_i877 = 0; $_i877 < $_size873; ++$_i877) { - $elem871 = null; - $xfer += $input->readString($elem871); - $this->tbl_types []= $elem871; + $elem878 = null; + $xfer += $input->readString($elem878); + $this->tbl_types []= $elem878; } $xfer += $input->readListEnd(); } else { @@ -18854,9 +18854,9 @@ class ThriftHiveMetastore_get_table_meta_args { { $output->writeListBegin(TType::STRING, count($this->tbl_types)); { - foreach ($this->tbl_types as $iter872) + foreach ($this->tbl_types as $iter879) { - $xfer += $output->writeString($iter872); + $xfer += $output->writeString($iter879); } } $output->writeListEnd(); @@ -18933,15 +18933,15 @@ class ThriftHiveMetastore_get_table_meta_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size873 = 0; - $_etype876 = 0; - $xfer += $input->readListBegin($_etype876, $_size873); - for ($_i877 = 0; $_i877 < $_size873; ++$_i877) + $_size880 = 0; + $_etype883 = 0; + $xfer += $input->readListBegin($_etype883, $_size880); + for ($_i884 = 0; $_i884 < $_size880; ++$_i884) { - $elem878 = null; - $elem878 = new \metastore\TableMeta(); - $xfer += $elem878->read($input); - $this->success []= $elem878; + $elem885 = null; + $elem885 = new \metastore\TableMeta(); + $xfer += $elem885->read($input); + $this->success []= $elem885; } $xfer += $input->readListEnd(); } else { @@ -18977,9 +18977,9 @@ class ThriftHiveMetastore_get_table_meta_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter879) + foreach ($this->success as $iter886) { - $xfer += $iter879->write($output); + $xfer += $iter886->write($output); } } $output->writeListEnd(); @@ -19135,14 +19135,14 @@ class ThriftHiveMetastore_get_all_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size880 = 0; - $_etype883 = 0; - $xfer += $input->readListBegin($_etype883, $_size880); - for ($_i884 = 0; $_i884 < $_size880; ++$_i884) + $_size887 = 0; + $_etype890 = 0; + $xfer += $input->readListBegin($_etype890, $_size887); + for ($_i891 = 0; $_i891 < $_size887; ++$_i891) { - $elem885 = null; - $xfer += $input->readString($elem885); - $this->success []= $elem885; + $elem892 = null; + $xfer += $input->readString($elem892); + $this->success []= $elem892; } $xfer += $input->readListEnd(); } else { @@ -19178,9 +19178,9 @@ class ThriftHiveMetastore_get_all_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter886) + foreach ($this->success as $iter893) { - $xfer += $output->writeString($iter886); + $xfer += $output->writeString($iter893); } } $output->writeListEnd(); @@ -19495,14 +19495,14 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { case 2: if ($ftype == TType::LST) { $this->tbl_names = array(); - $_size887 = 0; - $_etype890 = 0; - $xfer += $input->readListBegin($_etype890, $_size887); - for ($_i891 = 0; $_i891 < $_size887; ++$_i891) + $_size894 = 0; + $_etype897 = 0; + $xfer += $input->readListBegin($_etype897, $_size894); + for ($_i898 = 0; $_i898 < $_size894; ++$_i898) { - $elem892 = null; - $xfer += $input->readString($elem892); - $this->tbl_names []= $elem892; + $elem899 = null; + $xfer += $input->readString($elem899); + $this->tbl_names []= $elem899; } $xfer += $input->readListEnd(); } else { @@ -19535,9 +19535,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter893) + foreach ($this->tbl_names as $iter900) { - $xfer += $output->writeString($iter893); + $xfer += $output->writeString($iter900); } } $output->writeListEnd(); @@ -19602,15 +19602,15 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size894 = 0; - $_etype897 = 0; - $xfer += $input->readListBegin($_etype897, $_size894); - for ($_i898 = 0; $_i898 < $_size894; ++$_i898) + $_size901 = 0; + $_etype904 = 0; + $xfer += $input->readListBegin($_etype904, $_size901); + for ($_i905 = 0; $_i905 < $_size901; ++$_i905) { - $elem899 = null; - $elem899 = new \metastore\Table(); - $xfer += $elem899->read($input); - $this->success []= $elem899; + $elem906 = null; + $elem906 = new \metastore\Table(); + $xfer += $elem906->read($input); + $this->success []= $elem906; } $xfer += $input->readListEnd(); } else { @@ -19638,9 +19638,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter900) + foreach ($this->success as $iter907) { - $xfer += $iter900->write($output); + $xfer += $iter907->write($output); } } $output->writeListEnd(); @@ -20167,14 +20167,14 @@ class ThriftHiveMetastore_get_materialization_invalidation_info_args { case 2: if ($ftype == TType::LST) { $this->tbl_names = array(); - $_size901 = 0; - $_etype904 = 0; - $xfer += $input->readListBegin($_etype904, $_size901); - for ($_i905 = 0; $_i905 < $_size901; ++$_i905) + $_size908 = 0; + $_etype911 = 0; + $xfer += $input->readListBegin($_etype911, $_size908); + for ($_i912 = 0; $_i912 < $_size908; ++$_i912) { - $elem906 = null; - $xfer += $input->readString($elem906); - $this->tbl_names []= $elem906; + $elem913 = null; + $xfer += $input->readString($elem913); + $this->tbl_names []= $elem913; } $xfer += $input->readListEnd(); } else { @@ -20207,9 +20207,9 @@ class ThriftHiveMetastore_get_materialization_invalidation_info_args { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter907) + foreach ($this->tbl_names as $iter914) { - $xfer += $output->writeString($iter907); + $xfer += $output->writeString($iter914); } } $output->writeListEnd(); @@ -20314,18 +20314,18 @@ class ThriftHiveMetastore_get_materialization_invalidation_info_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size908 = 0; - $_ktype909 = 0; - $_vtype910 = 0; - $xfer += $input->readMapBegin($_ktype909, $_vtype910, $_size908); - for ($_i912 = 0; $_i912 < $_size908; ++$_i912) + $_size915 = 0; + $_ktype916 = 0; + $_vtype917 = 0; + $xfer += $input->readMapBegin($_ktype916, $_vtype917, $_size915); + for ($_i919 = 0; $_i919 < $_size915; ++$_i919) { - $key913 = ''; - $val914 = new \metastore\Materialization(); - $xfer += $input->readString($key913); - $val914 = new \metastore\Materialization(); - $xfer += $val914->read($input); - $this->success[$key913] = $val914; + $key920 = ''; + $val921 = new \metastore\Materialization(); + $xfer += $input->readString($key920); + $val921 = new \metastore\Materialization(); + $xfer += $val921->read($input); + $this->success[$key920] = $val921; } $xfer += $input->readMapEnd(); } else { @@ -20377,10 +20377,10 @@ class ThriftHiveMetastore_get_materialization_invalidation_info_result { { $output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->success)); { - foreach ($this->success as $kiter915 => $viter916) + foreach ($this->success as $kiter922 => $viter923) { - $xfer += $output->writeString($kiter915); - $xfer += $viter916->write($output); + $xfer += $output->writeString($kiter922); + $xfer += $viter923->write($output); } } $output->writeMapEnd(); @@ -20869,14 +20869,14 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size917 = 0; - $_etype920 = 0; - $xfer += $input->readListBegin($_etype920, $_size917); - for ($_i921 = 0; $_i921 < $_size917; ++$_i921) + $_size924 = 0; + $_etype927 = 0; + $xfer += $input->readListBegin($_etype927, $_size924); + for ($_i928 = 0; $_i928 < $_size924; ++$_i928) { - $elem922 = null; - $xfer += $input->readString($elem922); - $this->success []= $elem922; + $elem929 = null; + $xfer += $input->readString($elem929); + $this->success []= $elem929; } $xfer += $input->readListEnd(); } else { @@ -20928,9 +20928,9 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter923) + foreach ($this->success as $iter930) { - $xfer += $output->writeString($iter923); + $xfer += $output->writeString($iter930); } } $output->writeListEnd(); @@ -22243,15 +22243,15 @@ class ThriftHiveMetastore_add_partitions_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size924 = 0; - $_etype927 = 0; - $xfer += $input->readListBegin($_etype927, $_size924); - for ($_i928 = 0; $_i928 < $_size924; ++$_i928) + $_size931 = 0; + $_etype934 = 0; + $xfer += $input->readListBegin($_etype934, $_size931); + for ($_i935 = 0; $_i935 < $_size931; ++$_i935) { - $elem929 = null; - $elem929 = new \metastore\Partition(); - $xfer += $elem929->read($input); - $this->new_parts []= $elem929; + $elem936 = null; + $elem936 = new \metastore\Partition(); + $xfer += $elem936->read($input); + $this->new_parts []= $elem936; } $xfer += $input->readListEnd(); } else { @@ -22279,9 +22279,9 @@ class ThriftHiveMetastore_add_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter930) + foreach ($this->new_parts as $iter937) { - $xfer += $iter930->write($output); + $xfer += $iter937->write($output); } } $output->writeListEnd(); @@ -22496,15 +22496,15 @@ class ThriftHiveMetastore_add_partitions_pspec_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size931 = 0; - $_etype934 = 0; - $xfer += $input->readListBegin($_etype934, $_size931); - for ($_i935 = 0; $_i935 < $_size931; ++$_i935) + $_size938 = 0; + $_etype941 = 0; + $xfer += $input->readListBegin($_etype941, $_size938); + for ($_i942 = 0; $_i942 < $_size938; ++$_i942) { - $elem936 = null; - $elem936 = new \metastore\PartitionSpec(); - $xfer += $elem936->read($input); - $this->new_parts []= $elem936; + $elem943 = null; + $elem943 = new \metastore\PartitionSpec(); + $xfer += $elem943->read($input); + $this->new_parts []= $elem943; } $xfer += $input->readListEnd(); } else { @@ -22532,9 +22532,9 @@ class ThriftHiveMetastore_add_partitions_pspec_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter937) + foreach ($this->new_parts as $iter944) { - $xfer += $iter937->write($output); + $xfer += $iter944->write($output); } } $output->writeListEnd(); @@ -22784,14 +22784,14 @@ class ThriftHiveMetastore_append_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size938 = 0; - $_etype941 = 0; - $xfer += $input->readListBegin($_etype941, $_size938); - for ($_i942 = 0; $_i942 < $_size938; ++$_i942) + $_size945 = 0; + $_etype948 = 0; + $xfer += $input->readListBegin($_etype948, $_size945); + for ($_i949 = 0; $_i949 < $_size945; ++$_i949) { - $elem943 = null; - $xfer += $input->readString($elem943); - $this->part_vals []= $elem943; + $elem950 = null; + $xfer += $input->readString($elem950); + $this->part_vals []= $elem950; } $xfer += $input->readListEnd(); } else { @@ -22829,9 +22829,9 @@ class ThriftHiveMetastore_append_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter944) + foreach ($this->part_vals as $iter951) { - $xfer += $output->writeString($iter944); + $xfer += $output->writeString($iter951); } } $output->writeListEnd(); @@ -23333,14 +23333,14 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size945 = 0; - $_etype948 = 0; - $xfer += $input->readListBegin($_etype948, $_size945); - for ($_i949 = 0; $_i949 < $_size945; ++$_i949) + $_size952 = 0; + $_etype955 = 0; + $xfer += $input->readListBegin($_etype955, $_size952); + for ($_i956 = 0; $_i956 < $_size952; ++$_i956) { - $elem950 = null; - $xfer += $input->readString($elem950); - $this->part_vals []= $elem950; + $elem957 = null; + $xfer += $input->readString($elem957); + $this->part_vals []= $elem957; } $xfer += $input->readListEnd(); } else { @@ -23386,9 +23386,9 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter951) + foreach ($this->part_vals as $iter958) { - $xfer += $output->writeString($iter951); + $xfer += $output->writeString($iter958); } } $output->writeListEnd(); @@ -24242,14 +24242,14 @@ class ThriftHiveMetastore_drop_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size952 = 0; - $_etype955 = 0; - $xfer += $input->readListBegin($_etype955, $_size952); - for ($_i956 = 0; $_i956 < $_size952; ++$_i956) + $_size959 = 0; + $_etype962 = 0; + $xfer += $input->readListBegin($_etype962, $_size959); + for ($_i963 = 0; $_i963 < $_size959; ++$_i963) { - $elem957 = null; - $xfer += $input->readString($elem957); - $this->part_vals []= $elem957; + $elem964 = null; + $xfer += $input->readString($elem964); + $this->part_vals []= $elem964; } $xfer += $input->readListEnd(); } else { @@ -24294,9 +24294,9 @@ class ThriftHiveMetastore_drop_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter958) + foreach ($this->part_vals as $iter965) { - $xfer += $output->writeString($iter958); + $xfer += $output->writeString($iter965); } } $output->writeListEnd(); @@ -24549,14 +24549,14 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size959 = 0; - $_etype962 = 0; - $xfer += $input->readListBegin($_etype962, $_size959); - for ($_i963 = 0; $_i963 < $_size959; ++$_i963) + $_size966 = 0; + $_etype969 = 0; + $xfer += $input->readListBegin($_etype969, $_size966); + for ($_i970 = 0; $_i970 < $_size966; ++$_i970) { - $elem964 = null; - $xfer += $input->readString($elem964); - $this->part_vals []= $elem964; + $elem971 = null; + $xfer += $input->readString($elem971); + $this->part_vals []= $elem971; } $xfer += $input->readListEnd(); } else { @@ -24609,9 +24609,9 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter965) + foreach ($this->part_vals as $iter972) { - $xfer += $output->writeString($iter965); + $xfer += $output->writeString($iter972); } } $output->writeListEnd(); @@ -25625,14 +25625,14 @@ class ThriftHiveMetastore_get_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size966 = 0; - $_etype969 = 0; - $xfer += $input->readListBegin($_etype969, $_size966); - for ($_i970 = 0; $_i970 < $_size966; ++$_i970) + $_size973 = 0; + $_etype976 = 0; + $xfer += $input->readListBegin($_etype976, $_size973); + for ($_i977 = 0; $_i977 < $_size973; ++$_i977) { - $elem971 = null; - $xfer += $input->readString($elem971); - $this->part_vals []= $elem971; + $elem978 = null; + $xfer += $input->readString($elem978); + $this->part_vals []= $elem978; } $xfer += $input->readListEnd(); } else { @@ -25670,9 +25670,9 @@ class ThriftHiveMetastore_get_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter972) + foreach ($this->part_vals as $iter979) { - $xfer += $output->writeString($iter972); + $xfer += $output->writeString($iter979); } } $output->writeListEnd(); @@ -25914,17 +25914,17 @@ class ThriftHiveMetastore_exchange_partition_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size973 = 0; - $_ktype974 = 0; - $_vtype975 = 0; - $xfer += $input->readMapBegin($_ktype974, $_vtype975, $_size973); - for ($_i977 = 0; $_i977 < $_size973; ++$_i977) + $_size980 = 0; + $_ktype981 = 0; + $_vtype982 = 0; + $xfer += $input->readMapBegin($_ktype981, $_vtype982, $_size980); + for ($_i984 = 0; $_i984 < $_size980; ++$_i984) { - $key978 = ''; - $val979 = ''; - $xfer += $input->readString($key978); - $xfer += $input->readString($val979); - $this->partitionSpecs[$key978] = $val979; + $key985 = ''; + $val986 = ''; + $xfer += $input->readString($key985); + $xfer += $input->readString($val986); + $this->partitionSpecs[$key985] = $val986; } $xfer += $input->readMapEnd(); } else { @@ -25980,10 +25980,10 @@ class ThriftHiveMetastore_exchange_partition_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter980 => $viter981) + foreach ($this->partitionSpecs as $kiter987 => $viter988) { - $xfer += $output->writeString($kiter980); - $xfer += $output->writeString($viter981); + $xfer += $output->writeString($kiter987); + $xfer += $output->writeString($viter988); } } $output->writeMapEnd(); @@ -26295,17 +26295,17 @@ class ThriftHiveMetastore_exchange_partitions_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size982 = 0; - $_ktype983 = 0; - $_vtype984 = 0; - $xfer += $input->readMapBegin($_ktype983, $_vtype984, $_size982); - for ($_i986 = 0; $_i986 < $_size982; ++$_i986) + $_size989 = 0; + $_ktype990 = 0; + $_vtype991 = 0; + $xfer += $input->readMapBegin($_ktype990, $_vtype991, $_size989); + for ($_i993 = 0; $_i993 < $_size989; ++$_i993) { - $key987 = ''; - $val988 = ''; - $xfer += $input->readString($key987); - $xfer += $input->readString($val988); - $this->partitionSpecs[$key987] = $val988; + $key994 = ''; + $val995 = ''; + $xfer += $input->readString($key994); + $xfer += $input->readString($val995); + $this->partitionSpecs[$key994] = $val995; } $xfer += $input->readMapEnd(); } else { @@ -26361,10 +26361,10 @@ class ThriftHiveMetastore_exchange_partitions_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter989 => $viter990) + foreach ($this->partitionSpecs as $kiter996 => $viter997) { - $xfer += $output->writeString($kiter989); - $xfer += $output->writeString($viter990); + $xfer += $output->writeString($kiter996); + $xfer += $output->writeString($viter997); } } $output->writeMapEnd(); @@ -26497,15 +26497,15 @@ class ThriftHiveMetastore_exchange_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size991 = 0; - $_etype994 = 0; - $xfer += $input->readListBegin($_etype994, $_size991); - for ($_i995 = 0; $_i995 < $_size991; ++$_i995) + $_size998 = 0; + $_etype1001 = 0; + $xfer += $input->readListBegin($_etype1001, $_size998); + for ($_i1002 = 0; $_i1002 < $_size998; ++$_i1002) { - $elem996 = null; - $elem996 = new \metastore\Partition(); - $xfer += $elem996->read($input); - $this->success []= $elem996; + $elem1003 = null; + $elem1003 = new \metastore\Partition(); + $xfer += $elem1003->read($input); + $this->success []= $elem1003; } $xfer += $input->readListEnd(); } else { @@ -26565,9 +26565,9 @@ class ThriftHiveMetastore_exchange_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter997) + foreach ($this->success as $iter1004) { - $xfer += $iter997->write($output); + $xfer += $iter1004->write($output); } } $output->writeListEnd(); @@ -26713,14 +26713,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size998 = 0; - $_etype1001 = 0; - $xfer += $input->readListBegin($_etype1001, $_size998); - for ($_i1002 = 0; $_i1002 < $_size998; ++$_i1002) + $_size1005 = 0; + $_etype1008 = 0; + $xfer += $input->readListBegin($_etype1008, $_size1005); + for ($_i1009 = 0; $_i1009 < $_size1005; ++$_i1009) { - $elem1003 = null; - $xfer += $input->readString($elem1003); - $this->part_vals []= $elem1003; + $elem1010 = null; + $xfer += $input->readString($elem1010); + $this->part_vals []= $elem1010; } $xfer += $input->readListEnd(); } else { @@ -26737,14 +26737,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1004 = 0; - $_etype1007 = 0; - $xfer += $input->readListBegin($_etype1007, $_size1004); - for ($_i1008 = 0; $_i1008 < $_size1004; ++$_i1008) + $_size1011 = 0; + $_etype1014 = 0; + $xfer += $input->readListBegin($_etype1014, $_size1011); + for ($_i1015 = 0; $_i1015 < $_size1011; ++$_i1015) { - $elem1009 = null; - $xfer += $input->readString($elem1009); - $this->group_names []= $elem1009; + $elem1016 = null; + $xfer += $input->readString($elem1016); + $this->group_names []= $elem1016; } $xfer += $input->readListEnd(); } else { @@ -26782,9 +26782,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1010) + foreach ($this->part_vals as $iter1017) { - $xfer += $output->writeString($iter1010); + $xfer += $output->writeString($iter1017); } } $output->writeListEnd(); @@ -26804,9 +26804,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1011) + foreach ($this->group_names as $iter1018) { - $xfer += $output->writeString($iter1011); + $xfer += $output->writeString($iter1018); } } $output->writeListEnd(); @@ -27397,15 +27397,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1012 = 0; - $_etype1015 = 0; - $xfer += $input->readListBegin($_etype1015, $_size1012); - for ($_i1016 = 0; $_i1016 < $_size1012; ++$_i1016) + $_size1019 = 0; + $_etype1022 = 0; + $xfer += $input->readListBegin($_etype1022, $_size1019); + for ($_i1023 = 0; $_i1023 < $_size1019; ++$_i1023) { - $elem1017 = null; - $elem1017 = new \metastore\Partition(); - $xfer += $elem1017->read($input); - $this->success []= $elem1017; + $elem1024 = null; + $elem1024 = new \metastore\Partition(); + $xfer += $elem1024->read($input); + $this->success []= $elem1024; } $xfer += $input->readListEnd(); } else { @@ -27449,9 +27449,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1018) + foreach ($this->success as $iter1025) { - $xfer += $iter1018->write($output); + $xfer += $iter1025->write($output); } } $output->writeListEnd(); @@ -27597,14 +27597,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1019 = 0; - $_etype1022 = 0; - $xfer += $input->readListBegin($_etype1022, $_size1019); - for ($_i1023 = 0; $_i1023 < $_size1019; ++$_i1023) + $_size1026 = 0; + $_etype1029 = 0; + $xfer += $input->readListBegin($_etype1029, $_size1026); + for ($_i1030 = 0; $_i1030 < $_size1026; ++$_i1030) { - $elem1024 = null; - $xfer += $input->readString($elem1024); - $this->group_names []= $elem1024; + $elem1031 = null; + $xfer += $input->readString($elem1031); + $this->group_names []= $elem1031; } $xfer += $input->readListEnd(); } else { @@ -27652,9 +27652,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1025) + foreach ($this->group_names as $iter1032) { - $xfer += $output->writeString($iter1025); + $xfer += $output->writeString($iter1032); } } $output->writeListEnd(); @@ -27743,15 +27743,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1026 = 0; - $_etype1029 = 0; - $xfer += $input->readListBegin($_etype1029, $_size1026); - for ($_i1030 = 0; $_i1030 < $_size1026; ++$_i1030) + $_size1033 = 0; + $_etype1036 = 0; + $xfer += $input->readListBegin($_etype1036, $_size1033); + for ($_i1037 = 0; $_i1037 < $_size1033; ++$_i1037) { - $elem1031 = null; - $elem1031 = new \metastore\Partition(); - $xfer += $elem1031->read($input); - $this->success []= $elem1031; + $elem1038 = null; + $elem1038 = new \metastore\Partition(); + $xfer += $elem1038->read($input); + $this->success []= $elem1038; } $xfer += $input->readListEnd(); } else { @@ -27795,9 +27795,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1032) + foreach ($this->success as $iter1039) { - $xfer += $iter1032->write($output); + $xfer += $iter1039->write($output); } } $output->writeListEnd(); @@ -28017,15 +28017,15 @@ class ThriftHiveMetastore_get_partitions_pspec_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1033 = 0; - $_etype1036 = 0; - $xfer += $input->readListBegin($_etype1036, $_size1033); - for ($_i1037 = 0; $_i1037 < $_size1033; ++$_i1037) + $_size1040 = 0; + $_etype1043 = 0; + $xfer += $input->readListBegin($_etype1043, $_size1040); + for ($_i1044 = 0; $_i1044 < $_size1040; ++$_i1044) { - $elem1038 = null; - $elem1038 = new \metastore\PartitionSpec(); - $xfer += $elem1038->read($input); - $this->success []= $elem1038; + $elem1045 = null; + $elem1045 = new \metastore\PartitionSpec(); + $xfer += $elem1045->read($input); + $this->success []= $elem1045; } $xfer += $input->readListEnd(); } else { @@ -28069,9 +28069,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1039) + foreach ($this->success as $iter1046) { - $xfer += $iter1039->write($output); + $xfer += $iter1046->write($output); } } $output->writeListEnd(); @@ -28290,14 +28290,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1040 = 0; - $_etype1043 = 0; - $xfer += $input->readListBegin($_etype1043, $_size1040); - for ($_i1044 = 0; $_i1044 < $_size1040; ++$_i1044) + $_size1047 = 0; + $_etype1050 = 0; + $xfer += $input->readListBegin($_etype1050, $_size1047); + for ($_i1051 = 0; $_i1051 < $_size1047; ++$_i1051) { - $elem1045 = null; - $xfer += $input->readString($elem1045); - $this->success []= $elem1045; + $elem1052 = null; + $xfer += $input->readString($elem1052); + $this->success []= $elem1052; } $xfer += $input->readListEnd(); } else { @@ -28341,9 +28341,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1046) + foreach ($this->success as $iter1053) { - $xfer += $output->writeString($iter1046); + $xfer += $output->writeString($iter1053); } } $output->writeListEnd(); @@ -28674,14 +28674,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1047 = 0; - $_etype1050 = 0; - $xfer += $input->readListBegin($_etype1050, $_size1047); - for ($_i1051 = 0; $_i1051 < $_size1047; ++$_i1051) + $_size1054 = 0; + $_etype1057 = 0; + $xfer += $input->readListBegin($_etype1057, $_size1054); + for ($_i1058 = 0; $_i1058 < $_size1054; ++$_i1058) { - $elem1052 = null; - $xfer += $input->readString($elem1052); - $this->part_vals []= $elem1052; + $elem1059 = null; + $xfer += $input->readString($elem1059); + $this->part_vals []= $elem1059; } $xfer += $input->readListEnd(); } else { @@ -28726,9 +28726,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1053) + foreach ($this->part_vals as $iter1060) { - $xfer += $output->writeString($iter1053); + $xfer += $output->writeString($iter1060); } } $output->writeListEnd(); @@ -28822,15 +28822,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1054 = 0; - $_etype1057 = 0; - $xfer += $input->readListBegin($_etype1057, $_size1054); - for ($_i1058 = 0; $_i1058 < $_size1054; ++$_i1058) + $_size1061 = 0; + $_etype1064 = 0; + $xfer += $input->readListBegin($_etype1064, $_size1061); + for ($_i1065 = 0; $_i1065 < $_size1061; ++$_i1065) { - $elem1059 = null; - $elem1059 = new \metastore\Partition(); - $xfer += $elem1059->read($input); - $this->success []= $elem1059; + $elem1066 = null; + $elem1066 = new \metastore\Partition(); + $xfer += $elem1066->read($input); + $this->success []= $elem1066; } $xfer += $input->readListEnd(); } else { @@ -28874,9 +28874,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1060) + foreach ($this->success as $iter1067) { - $xfer += $iter1060->write($output); + $xfer += $iter1067->write($output); } } $output->writeListEnd(); @@ -29023,14 +29023,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1061 = 0; - $_etype1064 = 0; - $xfer += $input->readListBegin($_etype1064, $_size1061); - for ($_i1065 = 0; $_i1065 < $_size1061; ++$_i1065) + $_size1068 = 0; + $_etype1071 = 0; + $xfer += $input->readListBegin($_etype1071, $_size1068); + for ($_i1072 = 0; $_i1072 < $_size1068; ++$_i1072) { - $elem1066 = null; - $xfer += $input->readString($elem1066); - $this->part_vals []= $elem1066; + $elem1073 = null; + $xfer += $input->readString($elem1073); + $this->part_vals []= $elem1073; } $xfer += $input->readListEnd(); } else { @@ -29054,14 +29054,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1067 = 0; - $_etype1070 = 0; - $xfer += $input->readListBegin($_etype1070, $_size1067); - for ($_i1071 = 0; $_i1071 < $_size1067; ++$_i1071) + $_size1074 = 0; + $_etype1077 = 0; + $xfer += $input->readListBegin($_etype1077, $_size1074); + for ($_i1078 = 0; $_i1078 < $_size1074; ++$_i1078) { - $elem1072 = null; - $xfer += $input->readString($elem1072); - $this->group_names []= $elem1072; + $elem1079 = null; + $xfer += $input->readString($elem1079); + $this->group_names []= $elem1079; } $xfer += $input->readListEnd(); } else { @@ -29099,9 +29099,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1073) + foreach ($this->part_vals as $iter1080) { - $xfer += $output->writeString($iter1073); + $xfer += $output->writeString($iter1080); } } $output->writeListEnd(); @@ -29126,9 +29126,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1074) + foreach ($this->group_names as $iter1081) { - $xfer += $output->writeString($iter1074); + $xfer += $output->writeString($iter1081); } } $output->writeListEnd(); @@ -29217,15 +29217,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1075 = 0; - $_etype1078 = 0; - $xfer += $input->readListBegin($_etype1078, $_size1075); - for ($_i1079 = 0; $_i1079 < $_size1075; ++$_i1079) + $_size1082 = 0; + $_etype1085 = 0; + $xfer += $input->readListBegin($_etype1085, $_size1082); + for ($_i1086 = 0; $_i1086 < $_size1082; ++$_i1086) { - $elem1080 = null; - $elem1080 = new \metastore\Partition(); - $xfer += $elem1080->read($input); - $this->success []= $elem1080; + $elem1087 = null; + $elem1087 = new \metastore\Partition(); + $xfer += $elem1087->read($input); + $this->success []= $elem1087; } $xfer += $input->readListEnd(); } else { @@ -29269,9 +29269,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1081) + foreach ($this->success as $iter1088) { - $xfer += $iter1081->write($output); + $xfer += $iter1088->write($output); } } $output->writeListEnd(); @@ -29392,14 +29392,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1082 = 0; - $_etype1085 = 0; - $xfer += $input->readListBegin($_etype1085, $_size1082); - for ($_i1086 = 0; $_i1086 < $_size1082; ++$_i1086) + $_size1089 = 0; + $_etype1092 = 0; + $xfer += $input->readListBegin($_etype1092, $_size1089); + for ($_i1093 = 0; $_i1093 < $_size1089; ++$_i1093) { - $elem1087 = null; - $xfer += $input->readString($elem1087); - $this->part_vals []= $elem1087; + $elem1094 = null; + $xfer += $input->readString($elem1094); + $this->part_vals []= $elem1094; } $xfer += $input->readListEnd(); } else { @@ -29444,9 +29444,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1088) + foreach ($this->part_vals as $iter1095) { - $xfer += $output->writeString($iter1088); + $xfer += $output->writeString($iter1095); } } $output->writeListEnd(); @@ -29539,14 +29539,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1089 = 0; - $_etype1092 = 0; - $xfer += $input->readListBegin($_etype1092, $_size1089); - for ($_i1093 = 0; $_i1093 < $_size1089; ++$_i1093) + $_size1096 = 0; + $_etype1099 = 0; + $xfer += $input->readListBegin($_etype1099, $_size1096); + for ($_i1100 = 0; $_i1100 < $_size1096; ++$_i1100) { - $elem1094 = null; - $xfer += $input->readString($elem1094); - $this->success []= $elem1094; + $elem1101 = null; + $xfer += $input->readString($elem1101); + $this->success []= $elem1101; } $xfer += $input->readListEnd(); } else { @@ -29590,9 +29590,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1095) + foreach ($this->success as $iter1102) { - $xfer += $output->writeString($iter1095); + $xfer += $output->writeString($iter1102); } } $output->writeListEnd(); @@ -29835,15 +29835,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1096 = 0; - $_etype1099 = 0; - $xfer += $input->readListBegin($_etype1099, $_size1096); - for ($_i1100 = 0; $_i1100 < $_size1096; ++$_i1100) + $_size1103 = 0; + $_etype1106 = 0; + $xfer += $input->readListBegin($_etype1106, $_size1103); + for ($_i1107 = 0; $_i1107 < $_size1103; ++$_i1107) { - $elem1101 = null; - $elem1101 = new \metastore\Partition(); - $xfer += $elem1101->read($input); - $this->success []= $elem1101; + $elem1108 = null; + $elem1108 = new \metastore\Partition(); + $xfer += $elem1108->read($input); + $this->success []= $elem1108; } $xfer += $input->readListEnd(); } else { @@ -29887,9 +29887,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1102) + foreach ($this->success as $iter1109) { - $xfer += $iter1102->write($output); + $xfer += $iter1109->write($output); } } $output->writeListEnd(); @@ -30132,15 +30132,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1103 = 0; - $_etype1106 = 0; - $xfer += $input->readListBegin($_etype1106, $_size1103); - for ($_i1107 = 0; $_i1107 < $_size1103; ++$_i1107) + $_size1110 = 0; + $_etype1113 = 0; + $xfer += $input->readListBegin($_etype1113, $_size1110); + for ($_i1114 = 0; $_i1114 < $_size1110; ++$_i1114) { - $elem1108 = null; - $elem1108 = new \metastore\PartitionSpec(); - $xfer += $elem1108->read($input); - $this->success []= $elem1108; + $elem1115 = null; + $elem1115 = new \metastore\PartitionSpec(); + $xfer += $elem1115->read($input); + $this->success []= $elem1115; } $xfer += $input->readListEnd(); } else { @@ -30184,9 +30184,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1109) + foreach ($this->success as $iter1116) { - $xfer += $iter1109->write($output); + $xfer += $iter1116->write($output); } } $output->writeListEnd(); @@ -30752,14 +30752,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size1110 = 0; - $_etype1113 = 0; - $xfer += $input->readListBegin($_etype1113, $_size1110); - for ($_i1114 = 0; $_i1114 < $_size1110; ++$_i1114) + $_size1117 = 0; + $_etype1120 = 0; + $xfer += $input->readListBegin($_etype1120, $_size1117); + for ($_i1121 = 0; $_i1121 < $_size1117; ++$_i1121) { - $elem1115 = null; - $xfer += $input->readString($elem1115); - $this->names []= $elem1115; + $elem1122 = null; + $xfer += $input->readString($elem1122); + $this->names []= $elem1122; } $xfer += $input->readListEnd(); } else { @@ -30797,9 +30797,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter1116) + foreach ($this->names as $iter1123) { - $xfer += $output->writeString($iter1116); + $xfer += $output->writeString($iter1123); } } $output->writeListEnd(); @@ -30888,15 +30888,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1117 = 0; - $_etype1120 = 0; - $xfer += $input->readListBegin($_etype1120, $_size1117); - for ($_i1121 = 0; $_i1121 < $_size1117; ++$_i1121) + $_size1124 = 0; + $_etype1127 = 0; + $xfer += $input->readListBegin($_etype1127, $_size1124); + for ($_i1128 = 0; $_i1128 < $_size1124; ++$_i1128) { - $elem1122 = null; - $elem1122 = new \metastore\Partition(); - $xfer += $elem1122->read($input); - $this->success []= $elem1122; + $elem1129 = null; + $elem1129 = new \metastore\Partition(); + $xfer += $elem1129->read($input); + $this->success []= $elem1129; } $xfer += $input->readListEnd(); } else { @@ -30940,9 +30940,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1123) + foreach ($this->success as $iter1130) { - $xfer += $iter1123->write($output); + $xfer += $iter1130->write($output); } } $output->writeListEnd(); @@ -31281,15 +31281,15 @@ class ThriftHiveMetastore_alter_partitions_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size1124 = 0; - $_etype1127 = 0; - $xfer += $input->readListBegin($_etype1127, $_size1124); - for ($_i1128 = 0; $_i1128 < $_size1124; ++$_i1128) + $_size1131 = 0; + $_etype1134 = 0; + $xfer += $input->readListBegin($_etype1134, $_size1131); + for ($_i1135 = 0; $_i1135 < $_size1131; ++$_i1135) { - $elem1129 = null; - $elem1129 = new \metastore\Partition(); - $xfer += $elem1129->read($input); - $this->new_parts []= $elem1129; + $elem1136 = null; + $elem1136 = new \metastore\Partition(); + $xfer += $elem1136->read($input); + $this->new_parts []= $elem1136; } $xfer += $input->readListEnd(); } else { @@ -31327,9 +31327,9 @@ class ThriftHiveMetastore_alter_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter1130) + foreach ($this->new_parts as $iter1137) { - $xfer += $iter1130->write($output); + $xfer += $iter1137->write($output); } } $output->writeListEnd(); @@ -31544,15 +31544,15 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size1131 = 0; - $_etype1134 = 0; - $xfer += $input->readListBegin($_etype1134, $_size1131); - for ($_i1135 = 0; $_i1135 < $_size1131; ++$_i1135) + $_size1138 = 0; + $_etype1141 = 0; + $xfer += $input->readListBegin($_etype1141, $_size1138); + for ($_i1142 = 0; $_i1142 < $_size1138; ++$_i1142) { - $elem1136 = null; - $elem1136 = new \metastore\Partition(); - $xfer += $elem1136->read($input); - $this->new_parts []= $elem1136; + $elem1143 = null; + $elem1143 = new \metastore\Partition(); + $xfer += $elem1143->read($input); + $this->new_parts []= $elem1143; } $xfer += $input->readListEnd(); } else { @@ -31598,9 +31598,9 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter1137) + foreach ($this->new_parts as $iter1144) { - $xfer += $iter1137->write($output); + $xfer += $iter1144->write($output); } } $output->writeListEnd(); @@ -32078,14 +32078,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1138 = 0; - $_etype1141 = 0; - $xfer += $input->readListBegin($_etype1141, $_size1138); - for ($_i1142 = 0; $_i1142 < $_size1138; ++$_i1142) + $_size1145 = 0; + $_etype1148 = 0; + $xfer += $input->readListBegin($_etype1148, $_size1145); + for ($_i1149 = 0; $_i1149 < $_size1145; ++$_i1149) { - $elem1143 = null; - $xfer += $input->readString($elem1143); - $this->part_vals []= $elem1143; + $elem1150 = null; + $xfer += $input->readString($elem1150); + $this->part_vals []= $elem1150; } $xfer += $input->readListEnd(); } else { @@ -32131,9 +32131,9 @@ class ThriftHiveMetastore_rename_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1144) + foreach ($this->part_vals as $iter1151) { - $xfer += $output->writeString($iter1144); + $xfer += $output->writeString($iter1151); } } $output->writeListEnd(); @@ -32318,14 +32318,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1145 = 0; - $_etype1148 = 0; - $xfer += $input->readListBegin($_etype1148, $_size1145); - for ($_i1149 = 0; $_i1149 < $_size1145; ++$_i1149) + $_size1152 = 0; + $_etype1155 = 0; + $xfer += $input->readListBegin($_etype1155, $_size1152); + for ($_i1156 = 0; $_i1156 < $_size1152; ++$_i1156) { - $elem1150 = null; - $xfer += $input->readString($elem1150); - $this->part_vals []= $elem1150; + $elem1157 = null; + $xfer += $input->readString($elem1157); + $this->part_vals []= $elem1157; } $xfer += $input->readListEnd(); } else { @@ -32360,9 +32360,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1151) + foreach ($this->part_vals as $iter1158) { - $xfer += $output->writeString($iter1151); + $xfer += $output->writeString($iter1158); } } $output->writeListEnd(); @@ -32816,14 +32816,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1152 = 0; - $_etype1155 = 0; - $xfer += $input->readListBegin($_etype1155, $_size1152); - for ($_i1156 = 0; $_i1156 < $_size1152; ++$_i1156) + $_size1159 = 0; + $_etype1162 = 0; + $xfer += $input->readListBegin($_etype1162, $_size1159); + for ($_i1163 = 0; $_i1163 < $_size1159; ++$_i1163) { - $elem1157 = null; - $xfer += $input->readString($elem1157); - $this->success []= $elem1157; + $elem1164 = null; + $xfer += $input->readString($elem1164); + $this->success []= $elem1164; } $xfer += $input->readListEnd(); } else { @@ -32859,9 +32859,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1158) + foreach ($this->success as $iter1165) { - $xfer += $output->writeString($iter1158); + $xfer += $output->writeString($iter1165); } } $output->writeListEnd(); @@ -33021,17 +33021,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size1159 = 0; - $_ktype1160 = 0; - $_vtype1161 = 0; - $xfer += $input->readMapBegin($_ktype1160, $_vtype1161, $_size1159); - for ($_i1163 = 0; $_i1163 < $_size1159; ++$_i1163) + $_size1166 = 0; + $_ktype1167 = 0; + $_vtype1168 = 0; + $xfer += $input->readMapBegin($_ktype1167, $_vtype1168, $_size1166); + for ($_i1170 = 0; $_i1170 < $_size1166; ++$_i1170) { - $key1164 = ''; - $val1165 = ''; - $xfer += $input->readString($key1164); - $xfer += $input->readString($val1165); - $this->success[$key1164] = $val1165; + $key1171 = ''; + $val1172 = ''; + $xfer += $input->readString($key1171); + $xfer += $input->readString($val1172); + $this->success[$key1171] = $val1172; } $xfer += $input->readMapEnd(); } else { @@ -33067,10 +33067,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter1166 => $viter1167) + foreach ($this->success as $kiter1173 => $viter1174) { - $xfer += $output->writeString($kiter1166); - $xfer += $output->writeString($viter1167); + $xfer += $output->writeString($kiter1173); + $xfer += $output->writeString($viter1174); } } $output->writeMapEnd(); @@ -33190,17 +33190,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size1168 = 0; - $_ktype1169 = 0; - $_vtype1170 = 0; - $xfer += $input->readMapBegin($_ktype1169, $_vtype1170, $_size1168); - for ($_i1172 = 0; $_i1172 < $_size1168; ++$_i1172) + $_size1175 = 0; + $_ktype1176 = 0; + $_vtype1177 = 0; + $xfer += $input->readMapBegin($_ktype1176, $_vtype1177, $_size1175); + for ($_i1179 = 0; $_i1179 < $_size1175; ++$_i1179) { - $key1173 = ''; - $val1174 = ''; - $xfer += $input->readString($key1173); - $xfer += $input->readString($val1174); - $this->part_vals[$key1173] = $val1174; + $key1180 = ''; + $val1181 = ''; + $xfer += $input->readString($key1180); + $xfer += $input->readString($val1181); + $this->part_vals[$key1180] = $val1181; } $xfer += $input->readMapEnd(); } else { @@ -33245,10 +33245,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter1175 => $viter1176) + foreach ($this->part_vals as $kiter1182 => $viter1183) { - $xfer += $output->writeString($kiter1175); - $xfer += $output->writeString($viter1176); + $xfer += $output->writeString($kiter1182); + $xfer += $output->writeString($viter1183); } } $output->writeMapEnd(); @@ -33570,17 +33570,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size1177 = 0; - $_ktype1178 = 0; - $_vtype1179 = 0; - $xfer += $input->readMapBegin($_ktype1178, $_vtype1179, $_size1177); - for ($_i1181 = 0; $_i1181 < $_size1177; ++$_i1181) + $_size1184 = 0; + $_ktype1185 = 0; + $_vtype1186 = 0; + $xfer += $input->readMapBegin($_ktype1185, $_vtype1186, $_size1184); + for ($_i1188 = 0; $_i1188 < $_size1184; ++$_i1188) { - $key1182 = ''; - $val1183 = ''; - $xfer += $input->readString($key1182); - $xfer += $input->readString($val1183); - $this->part_vals[$key1182] = $val1183; + $key1189 = ''; + $val1190 = ''; + $xfer += $input->readString($key1189); + $xfer += $input->readString($val1190); + $this->part_vals[$key1189] = $val1190; } $xfer += $input->readMapEnd(); } else { @@ -33625,10 +33625,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter1184 => $viter1185) + foreach ($this->part_vals as $kiter1191 => $viter1192) { - $xfer += $output->writeString($kiter1184); - $xfer += $output->writeString($viter1185); + $xfer += $output->writeString($kiter1191); + $xfer += $output->writeString($viter1192); } } $output->writeMapEnd(); @@ -35102,15 +35102,15 @@ class ThriftHiveMetastore_get_indexes_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1186 = 0; - $_etype1189 = 0; - $xfer += $input->readListBegin($_etype1189, $_size1186); - for ($_i1190 = 0; $_i1190 < $_size1186; ++$_i1190) + $_size1193 = 0; + $_etype1196 = 0; + $xfer += $input->readListBegin($_etype1196, $_size1193); + for ($_i1197 = 0; $_i1197 < $_size1193; ++$_i1197) { - $elem1191 = null; - $elem1191 = new \metastore\Index(); - $xfer += $elem1191->read($input); - $this->success []= $elem1191; + $elem1198 = null; + $elem1198 = new \metastore\Index(); + $xfer += $elem1198->read($input); + $this->success []= $elem1198; } $xfer += $input->readListEnd(); } else { @@ -35154,9 +35154,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1192) + foreach ($this->success as $iter1199) { - $xfer += $iter1192->write($output); + $xfer += $iter1199->write($output); } } $output->writeListEnd(); @@ -35363,14 +35363,14 @@ class ThriftHiveMetastore_get_index_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1193 = 0; - $_etype1196 = 0; - $xfer += $input->readListBegin($_etype1196, $_size1193); - for ($_i1197 = 0; $_i1197 < $_size1193; ++$_i1197) + $_size1200 = 0; + $_etype1203 = 0; + $xfer += $input->readListBegin($_etype1203, $_size1200); + for ($_i1204 = 0; $_i1204 < $_size1200; ++$_i1204) { - $elem1198 = null; - $xfer += $input->readString($elem1198); - $this->success []= $elem1198; + $elem1205 = null; + $xfer += $input->readString($elem1205); + $this->success []= $elem1205; } $xfer += $input->readListEnd(); } else { @@ -35406,9 +35406,9 @@ class ThriftHiveMetastore_get_index_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1199) + foreach ($this->success as $iter1206) { - $xfer += $output->writeString($iter1199); + $xfer += $output->writeString($iter1206); } } $output->writeListEnd(); @@ -39722,14 +39722,14 @@ class ThriftHiveMetastore_get_functions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1200 = 0; - $_etype1203 = 0; - $xfer += $input->readListBegin($_etype1203, $_size1200); - for ($_i1204 = 0; $_i1204 < $_size1200; ++$_i1204) + $_size1207 = 0; + $_etype1210 = 0; + $xfer += $input->readListBegin($_etype1210, $_size1207); + for ($_i1211 = 0; $_i1211 < $_size1207; ++$_i1211) { - $elem1205 = null; - $xfer += $input->readString($elem1205); - $this->success []= $elem1205; + $elem1212 = null; + $xfer += $input->readString($elem1212); + $this->success []= $elem1212; } $xfer += $input->readListEnd(); } else { @@ -39765,9 +39765,9 @@ class ThriftHiveMetastore_get_functions_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1206) + foreach ($this->success as $iter1213) { - $xfer += $output->writeString($iter1206); + $xfer += $output->writeString($iter1213); } } $output->writeListEnd(); @@ -40636,14 +40636,14 @@ class ThriftHiveMetastore_get_role_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1207 = 0; - $_etype1210 = 0; - $xfer += $input->readListBegin($_etype1210, $_size1207); - for ($_i1211 = 0; $_i1211 < $_size1207; ++$_i1211) + $_size1214 = 0; + $_etype1217 = 0; + $xfer += $input->readListBegin($_etype1217, $_size1214); + for ($_i1218 = 0; $_i1218 < $_size1214; ++$_i1218) { - $elem1212 = null; - $xfer += $input->readString($elem1212); - $this->success []= $elem1212; + $elem1219 = null; + $xfer += $input->readString($elem1219); + $this->success []= $elem1219; } $xfer += $input->readListEnd(); } else { @@ -40679,9 +40679,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1213) + foreach ($this->success as $iter1220) { - $xfer += $output->writeString($iter1213); + $xfer += $output->writeString($iter1220); } } $output->writeListEnd(); @@ -41372,15 +41372,15 @@ class ThriftHiveMetastore_list_roles_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1214 = 0; - $_etype1217 = 0; - $xfer += $input->readListBegin($_etype1217, $_size1214); - for ($_i1218 = 0; $_i1218 < $_size1214; ++$_i1218) + $_size1221 = 0; + $_etype1224 = 0; + $xfer += $input->readListBegin($_etype1224, $_size1221); + for ($_i1225 = 0; $_i1225 < $_size1221; ++$_i1225) { - $elem1219 = null; - $elem1219 = new \metastore\Role(); - $xfer += $elem1219->read($input); - $this->success []= $elem1219; + $elem1226 = null; + $elem1226 = new \metastore\Role(); + $xfer += $elem1226->read($input); + $this->success []= $elem1226; } $xfer += $input->readListEnd(); } else { @@ -41416,9 +41416,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1220) + foreach ($this->success as $iter1227) { - $xfer += $iter1220->write($output); + $xfer += $iter1227->write($output); } } $output->writeListEnd(); @@ -42080,14 +42080,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1221 = 0; - $_etype1224 = 0; - $xfer += $input->readListBegin($_etype1224, $_size1221); - for ($_i1225 = 0; $_i1225 < $_size1221; ++$_i1225) + $_size1228 = 0; + $_etype1231 = 0; + $xfer += $input->readListBegin($_etype1231, $_size1228); + for ($_i1232 = 0; $_i1232 < $_size1228; ++$_i1232) { - $elem1226 = null; - $xfer += $input->readString($elem1226); - $this->group_names []= $elem1226; + $elem1233 = null; + $xfer += $input->readString($elem1233); + $this->group_names []= $elem1233; } $xfer += $input->readListEnd(); } else { @@ -42128,9 +42128,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1227) + foreach ($this->group_names as $iter1234) { - $xfer += $output->writeString($iter1227); + $xfer += $output->writeString($iter1234); } } $output->writeListEnd(); @@ -42438,15 +42438,15 @@ class ThriftHiveMetastore_list_privileges_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1228 = 0; - $_etype1231 = 0; - $xfer += $input->readListBegin($_etype1231, $_size1228); - for ($_i1232 = 0; $_i1232 < $_size1228; ++$_i1232) + $_size1235 = 0; + $_etype1238 = 0; + $xfer += $input->readListBegin($_etype1238, $_size1235); + for ($_i1239 = 0; $_i1239 < $_size1235; ++$_i1239) { - $elem1233 = null; - $elem1233 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem1233->read($input); - $this->success []= $elem1233; + $elem1240 = null; + $elem1240 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem1240->read($input); + $this->success []= $elem1240; } $xfer += $input->readListEnd(); } else { @@ -42482,9 +42482,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1234) + foreach ($this->success as $iter1241) { - $xfer += $iter1234->write($output); + $xfer += $iter1241->write($output); } } $output->writeListEnd(); @@ -43116,14 +43116,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1235 = 0; - $_etype1238 = 0; - $xfer += $input->readListBegin($_etype1238, $_size1235); - for ($_i1239 = 0; $_i1239 < $_size1235; ++$_i1239) + $_size1242 = 0; + $_etype1245 = 0; + $xfer += $input->readListBegin($_etype1245, $_size1242); + for ($_i1246 = 0; $_i1246 < $_size1242; ++$_i1246) { - $elem1240 = null; - $xfer += $input->readString($elem1240); - $this->group_names []= $elem1240; + $elem1247 = null; + $xfer += $input->readString($elem1247); + $this->group_names []= $elem1247; } $xfer += $input->readListEnd(); } else { @@ -43156,9 +43156,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1241) + foreach ($this->group_names as $iter1248) { - $xfer += $output->writeString($iter1241); + $xfer += $output->writeString($iter1248); } } $output->writeListEnd(); @@ -43234,14 +43234,14 @@ class ThriftHiveMetastore_set_ugi_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1242 = 0; - $_etype1245 = 0; - $xfer += $input->readListBegin($_etype1245, $_size1242); - for ($_i1246 = 0; $_i1246 < $_size1242; ++$_i1246) + $_size1249 = 0; + $_etype1252 = 0; + $xfer += $input->readListBegin($_etype1252, $_size1249); + for ($_i1253 = 0; $_i1253 < $_size1249; ++$_i1253) { - $elem1247 = null; - $xfer += $input->readString($elem1247); - $this->success []= $elem1247; + $elem1254 = null; + $xfer += $input->readString($elem1254); + $this->success []= $elem1254; } $xfer += $input->readListEnd(); } else { @@ -43277,9 +43277,9 @@ class ThriftHiveMetastore_set_ugi_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1248) + foreach ($this->success as $iter1255) { - $xfer += $output->writeString($iter1248); + $xfer += $output->writeString($iter1255); } } $output->writeListEnd(); @@ -44396,14 +44396,14 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1249 = 0; - $_etype1252 = 0; - $xfer += $input->readListBegin($_etype1252, $_size1249); - for ($_i1253 = 0; $_i1253 < $_size1249; ++$_i1253) + $_size1256 = 0; + $_etype1259 = 0; + $xfer += $input->readListBegin($_etype1259, $_size1256); + for ($_i1260 = 0; $_i1260 < $_size1256; ++$_i1260) { - $elem1254 = null; - $xfer += $input->readString($elem1254); - $this->success []= $elem1254; + $elem1261 = null; + $xfer += $input->readString($elem1261); + $this->success []= $elem1261; } $xfer += $input->readListEnd(); } else { @@ -44431,9 +44431,9 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1255) + foreach ($this->success as $iter1262) { - $xfer += $output->writeString($iter1255); + $xfer += $output->writeString($iter1262); } } $output->writeListEnd(); @@ -45072,14 +45072,14 @@ class ThriftHiveMetastore_get_master_keys_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1256 = 0; - $_etype1259 = 0; - $xfer += $input->readListBegin($_etype1259, $_size1256); - for ($_i1260 = 0; $_i1260 < $_size1256; ++$_i1260) + $_size1263 = 0; + $_etype1266 = 0; + $xfer += $input->readListBegin($_etype1266, $_size1263); + for ($_i1267 = 0; $_i1267 < $_size1263; ++$_i1267) { - $elem1261 = null; - $xfer += $input->readString($elem1261); - $this->success []= $elem1261; + $elem1268 = null; + $xfer += $input->readString($elem1268); + $this->success []= $elem1268; } $xfer += $input->readListEnd(); } else { @@ -45107,9 +45107,9 @@ class ThriftHiveMetastore_get_master_keys_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1262) + foreach ($this->success as $iter1269) { - $xfer += $output->writeString($iter1262); + $xfer += $output->writeString($iter1269); } } $output->writeListEnd(); diff --git a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php index a6047bf7b3..41bd257b14 100644 --- a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -13859,6 +13859,14 @@ class OpenTxnRequest { * @var string */ public $agentInfo = "Unknown"; + /** + * @var string + */ + public $replPolicy = null; + /** + * @var int[] + */ + public $replSrcTxnId = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -13879,6 +13887,18 @@ class OpenTxnRequest { 'var' => 'agentInfo', 'type' => TType::STRING, ), + 5 => array( + 'var' => 'replPolicy', + 'type' => TType::STRING, + ), + 6 => array( + 'var' => 'replSrcTxnId', + 'type' => TType::LST, + 'etype' => TType::I64, + 'elem' => array( + 'type' => TType::I64, + ), + ), ); } if (is_array($vals)) { @@ -13894,6 +13914,12 @@ class OpenTxnRequest { if (isset($vals['agentInfo'])) { $this->agentInfo = $vals['agentInfo']; } + if (isset($vals['replPolicy'])) { + $this->replPolicy = $vals['replPolicy']; + } + if (isset($vals['replSrcTxnId'])) { + $this->replSrcTxnId = $vals['replSrcTxnId']; + } } } @@ -13944,6 +13970,30 @@ class OpenTxnRequest { $xfer += $input->skip($ftype); } break; + case 5: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->replPolicy); + } else { + $xfer += $input->skip($ftype); + } + break; + case 6: + if ($ftype == TType::LST) { + $this->replSrcTxnId = array(); + $_size476 = 0; + $_etype479 = 0; + $xfer += $input->readListBegin($_etype479, $_size476); + for ($_i480 = 0; $_i480 < $_size476; ++$_i480) + { + $elem481 = null; + $xfer += $input->readI64($elem481); + $this->replSrcTxnId []= $elem481; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -13977,6 +14027,28 @@ class OpenTxnRequest { $xfer += $output->writeString($this->agentInfo); $xfer += $output->writeFieldEnd(); } + if ($this->replPolicy !== null) { + $xfer += $output->writeFieldBegin('replPolicy', TType::STRING, 5); + $xfer += $output->writeString($this->replPolicy); + $xfer += $output->writeFieldEnd(); + } + if ($this->replSrcTxnId !== null) { + if (!is_array($this->replSrcTxnId)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('replSrcTxnId', TType::LST, 6); + { + $output->writeListBegin(TType::I64, count($this->replSrcTxnId)); + { + foreach ($this->replSrcTxnId as $iter482) + { + $xfer += $output->writeI64($iter482); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -14034,14 +14106,14 @@ class OpenTxnsResponse { case 1: if ($ftype == TType::LST) { $this->txn_ids = array(); - $_size476 = 0; - $_etype479 = 0; - $xfer += $input->readListBegin($_etype479, $_size476); - for ($_i480 = 0; $_i480 < $_size476; ++$_i480) + $_size483 = 0; + $_etype486 = 0; + $xfer += $input->readListBegin($_etype486, $_size483); + for ($_i487 = 0; $_i487 < $_size483; ++$_i487) { - $elem481 = null; - $xfer += $input->readI64($elem481); - $this->txn_ids []= $elem481; + $elem488 = null; + $xfer += $input->readI64($elem488); + $this->txn_ids []= $elem488; } $xfer += $input->readListEnd(); } else { @@ -14069,9 +14141,9 @@ class OpenTxnsResponse { { $output->writeListBegin(TType::I64, count($this->txn_ids)); { - foreach ($this->txn_ids as $iter482) + foreach ($this->txn_ids as $iter489) { - $xfer += $output->writeI64($iter482); + $xfer += $output->writeI64($iter489); } } $output->writeListEnd(); @@ -14092,6 +14164,10 @@ class AbortTxnRequest { * @var int */ public $txnid = null; + /** + * @var string + */ + public $replPolicy = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -14100,12 +14176,19 @@ class AbortTxnRequest { 'var' => 'txnid', 'type' => TType::I64, ), + 2 => array( + 'var' => 'replPolicy', + 'type' => TType::STRING, + ), ); } if (is_array($vals)) { if (isset($vals['txnid'])) { $this->txnid = $vals['txnid']; } + if (isset($vals['replPolicy'])) { + $this->replPolicy = $vals['replPolicy']; + } } } @@ -14135,6 +14218,13 @@ class AbortTxnRequest { $xfer += $input->skip($ftype); } break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->replPolicy); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -14153,6 +14243,11 @@ class AbortTxnRequest { $xfer += $output->writeI64($this->txnid); $xfer += $output->writeFieldEnd(); } + if ($this->replPolicy !== null) { + $xfer += $output->writeFieldBegin('replPolicy', TType::STRING, 2); + $xfer += $output->writeString($this->replPolicy); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -14210,14 +14305,14 @@ class AbortTxnsRequest { case 1: if ($ftype == TType::LST) { $this->txn_ids = array(); - $_size483 = 0; - $_etype486 = 0; - $xfer += $input->readListBegin($_etype486, $_size483); - for ($_i487 = 0; $_i487 < $_size483; ++$_i487) + $_size490 = 0; + $_etype493 = 0; + $xfer += $input->readListBegin($_etype493, $_size490); + for ($_i494 = 0; $_i494 < $_size490; ++$_i494) { - $elem488 = null; - $xfer += $input->readI64($elem488); - $this->txn_ids []= $elem488; + $elem495 = null; + $xfer += $input->readI64($elem495); + $this->txn_ids []= $elem495; } $xfer += $input->readListEnd(); } else { @@ -14245,9 +14340,9 @@ class AbortTxnsRequest { { $output->writeListBegin(TType::I64, count($this->txn_ids)); { - foreach ($this->txn_ids as $iter489) + foreach ($this->txn_ids as $iter496) { - $xfer += $output->writeI64($iter489); + $xfer += $output->writeI64($iter496); } } $output->writeListEnd(); @@ -14268,6 +14363,10 @@ class CommitTxnRequest { * @var int */ public $txnid = null; + /** + * @var string + */ + public $replPolicy = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -14276,12 +14375,19 @@ class CommitTxnRequest { 'var' => 'txnid', 'type' => TType::I64, ), + 2 => array( + 'var' => 'replPolicy', + 'type' => TType::STRING, + ), ); } if (is_array($vals)) { if (isset($vals['txnid'])) { $this->txnid = $vals['txnid']; } + if (isset($vals['replPolicy'])) { + $this->replPolicy = $vals['replPolicy']; + } } } @@ -14311,6 +14417,13 @@ class CommitTxnRequest { $xfer += $input->skip($ftype); } break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->replPolicy); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -14329,6 +14442,161 @@ class CommitTxnRequest { $xfer += $output->writeI64($this->txnid); $xfer += $output->writeFieldEnd(); } + if ($this->replPolicy !== null) { + $xfer += $output->writeFieldBegin('replPolicy', TType::STRING, 2); + $xfer += $output->writeString($this->replPolicy); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class GetTargetTxnIdRequest { + static $_TSPEC; + + /** + * @var int + */ + public $txnid = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'txnid', + 'type' => TType::I64, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['txnid'])) { + $this->txnid = $vals['txnid']; + } + } + } + + public function getName() { + return 'GetTargetTxnIdRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->txnid); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('GetTargetTxnIdRequest'); + if ($this->txnid !== null) { + $xfer += $output->writeFieldBegin('txnid', TType::I64, 1); + $xfer += $output->writeI64($this->txnid); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class GetTargetTxnIdResponse { + static $_TSPEC; + + /** + * @var int + */ + public $txnid = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'txnid', + 'type' => TType::I64, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['txnid'])) { + $this->txnid = $vals['txnid']; + } + } + } + + public function getName() { + return 'GetTargetTxnIdResponse'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->txnid); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('GetTargetTxnIdResponse'); + if ($this->txnid !== null) { + $xfer += $output->writeFieldBegin('txnid', TType::I64, 1); + $xfer += $output->writeI64($this->txnid); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -14397,14 +14665,14 @@ class GetValidWriteIdsRequest { case 1: if ($ftype == TType::LST) { $this->fullTableNames = array(); - $_size490 = 0; - $_etype493 = 0; - $xfer += $input->readListBegin($_etype493, $_size490); - for ($_i494 = 0; $_i494 < $_size490; ++$_i494) + $_size497 = 0; + $_etype500 = 0; + $xfer += $input->readListBegin($_etype500, $_size497); + for ($_i501 = 0; $_i501 < $_size497; ++$_i501) { - $elem495 = null; - $xfer += $input->readString($elem495); - $this->fullTableNames []= $elem495; + $elem502 = null; + $xfer += $input->readString($elem502); + $this->fullTableNames []= $elem502; } $xfer += $input->readListEnd(); } else { @@ -14439,9 +14707,9 @@ class GetValidWriteIdsRequest { { $output->writeListBegin(TType::STRING, count($this->fullTableNames)); { - foreach ($this->fullTableNames as $iter496) + foreach ($this->fullTableNames as $iter503) { - $xfer += $output->writeString($iter496); + $xfer += $output->writeString($iter503); } } $output->writeListEnd(); @@ -14568,14 +14836,14 @@ class TableValidWriteIds { case 3: if ($ftype == TType::LST) { $this->invalidWriteIds = array(); - $_size497 = 0; - $_etype500 = 0; - $xfer += $input->readListBegin($_etype500, $_size497); - for ($_i501 = 0; $_i501 < $_size497; ++$_i501) + $_size504 = 0; + $_etype507 = 0; + $xfer += $input->readListBegin($_etype507, $_size504); + for ($_i508 = 0; $_i508 < $_size504; ++$_i508) { - $elem502 = null; - $xfer += $input->readI64($elem502); - $this->invalidWriteIds []= $elem502; + $elem509 = null; + $xfer += $input->readI64($elem509); + $this->invalidWriteIds []= $elem509; } $xfer += $input->readListEnd(); } else { @@ -14627,9 +14895,9 @@ class TableValidWriteIds { { $output->writeListBegin(TType::I64, count($this->invalidWriteIds)); { - foreach ($this->invalidWriteIds as $iter503) + foreach ($this->invalidWriteIds as $iter510) { - $xfer += $output->writeI64($iter503); + $xfer += $output->writeI64($iter510); } } $output->writeListEnd(); @@ -14704,15 +14972,15 @@ class GetValidWriteIdsResponse { case 1: if ($ftype == TType::LST) { $this->tblValidWriteIds = array(); - $_size504 = 0; - $_etype507 = 0; - $xfer += $input->readListBegin($_etype507, $_size504); - for ($_i508 = 0; $_i508 < $_size504; ++$_i508) + $_size511 = 0; + $_etype514 = 0; + $xfer += $input->readListBegin($_etype514, $_size511); + for ($_i515 = 0; $_i515 < $_size511; ++$_i515) { - $elem509 = null; - $elem509 = new \metastore\TableValidWriteIds(); - $xfer += $elem509->read($input); - $this->tblValidWriteIds []= $elem509; + $elem516 = null; + $elem516 = new \metastore\TableValidWriteIds(); + $xfer += $elem516->read($input); + $this->tblValidWriteIds []= $elem516; } $xfer += $input->readListEnd(); } else { @@ -14740,9 +15008,9 @@ class GetValidWriteIdsResponse { { $output->writeListBegin(TType::STRUCT, count($this->tblValidWriteIds)); { - foreach ($this->tblValidWriteIds as $iter510) + foreach ($this->tblValidWriteIds as $iter517) { - $xfer += $iter510->write($output); + $xfer += $iter517->write($output); } } $output->writeListEnd(); @@ -14828,14 +15096,14 @@ class AllocateTableWriteIdsRequest { case 1: if ($ftype == TType::LST) { $this->txnIds = array(); - $_size511 = 0; - $_etype514 = 0; - $xfer += $input->readListBegin($_etype514, $_size511); - for ($_i515 = 0; $_i515 < $_size511; ++$_i515) + $_size518 = 0; + $_etype521 = 0; + $xfer += $input->readListBegin($_etype521, $_size518); + for ($_i522 = 0; $_i522 < $_size518; ++$_i522) { - $elem516 = null; - $xfer += $input->readI64($elem516); - $this->txnIds []= $elem516; + $elem523 = null; + $xfer += $input->readI64($elem523); + $this->txnIds []= $elem523; } $xfer += $input->readListEnd(); } else { @@ -14877,9 +15145,9 @@ class AllocateTableWriteIdsRequest { { $output->writeListBegin(TType::I64, count($this->txnIds)); { - foreach ($this->txnIds as $iter517) + foreach ($this->txnIds as $iter524) { - $xfer += $output->writeI64($iter517); + $xfer += $output->writeI64($iter524); } } $output->writeListEnd(); @@ -15052,15 +15320,15 @@ class AllocateTableWriteIdsResponse { case 1: if ($ftype == TType::LST) { $this->txnToWriteIds = array(); - $_size518 = 0; - $_etype521 = 0; - $xfer += $input->readListBegin($_etype521, $_size518); - for ($_i522 = 0; $_i522 < $_size518; ++$_i522) + $_size525 = 0; + $_etype528 = 0; + $xfer += $input->readListBegin($_etype528, $_size525); + for ($_i529 = 0; $_i529 < $_size525; ++$_i529) { - $elem523 = null; - $elem523 = new \metastore\TxnToWriteId(); - $xfer += $elem523->read($input); - $this->txnToWriteIds []= $elem523; + $elem530 = null; + $elem530 = new \metastore\TxnToWriteId(); + $xfer += $elem530->read($input); + $this->txnToWriteIds []= $elem530; } $xfer += $input->readListEnd(); } else { @@ -15088,9 +15356,9 @@ class AllocateTableWriteIdsResponse { { $output->writeListBegin(TType::STRUCT, count($this->txnToWriteIds)); { - foreach ($this->txnToWriteIds as $iter524) + foreach ($this->txnToWriteIds as $iter531) { - $xfer += $iter524->write($output); + $xfer += $iter531->write($output); } } $output->writeListEnd(); @@ -15435,15 +15703,15 @@ class LockRequest { case 1: if ($ftype == TType::LST) { $this->component = array(); - $_size525 = 0; - $_etype528 = 0; - $xfer += $input->readListBegin($_etype528, $_size525); - for ($_i529 = 0; $_i529 < $_size525; ++$_i529) + $_size532 = 0; + $_etype535 = 0; + $xfer += $input->readListBegin($_etype535, $_size532); + for ($_i536 = 0; $_i536 < $_size532; ++$_i536) { - $elem530 = null; - $elem530 = new \metastore\LockComponent(); - $xfer += $elem530->read($input); - $this->component []= $elem530; + $elem537 = null; + $elem537 = new \metastore\LockComponent(); + $xfer += $elem537->read($input); + $this->component []= $elem537; } $xfer += $input->readListEnd(); } else { @@ -15499,9 +15767,9 @@ class LockRequest { { $output->writeListBegin(TType::STRUCT, count($this->component)); { - foreach ($this->component as $iter531) + foreach ($this->component as $iter538) { - $xfer += $iter531->write($output); + $xfer += $iter538->write($output); } } $output->writeListEnd(); @@ -16444,15 +16712,15 @@ class ShowLocksResponse { case 1: if ($ftype == TType::LST) { $this->locks = array(); - $_size532 = 0; - $_etype535 = 0; - $xfer += $input->readListBegin($_etype535, $_size532); - for ($_i536 = 0; $_i536 < $_size532; ++$_i536) + $_size539 = 0; + $_etype542 = 0; + $xfer += $input->readListBegin($_etype542, $_size539); + for ($_i543 = 0; $_i543 < $_size539; ++$_i543) { - $elem537 = null; - $elem537 = new \metastore\ShowLocksResponseElement(); - $xfer += $elem537->read($input); - $this->locks []= $elem537; + $elem544 = null; + $elem544 = new \metastore\ShowLocksResponseElement(); + $xfer += $elem544->read($input); + $this->locks []= $elem544; } $xfer += $input->readListEnd(); } else { @@ -16480,9 +16748,9 @@ class ShowLocksResponse { { $output->writeListBegin(TType::STRUCT, count($this->locks)); { - foreach ($this->locks as $iter538) + foreach ($this->locks as $iter545) { - $xfer += $iter538->write($output); + $xfer += $iter545->write($output); } } $output->writeListEnd(); @@ -16757,17 +17025,17 @@ class HeartbeatTxnRangeResponse { case 1: if ($ftype == TType::SET) { $this->aborted = array(); - $_size539 = 0; - $_etype542 = 0; - $xfer += $input->readSetBegin($_etype542, $_size539); - for ($_i543 = 0; $_i543 < $_size539; ++$_i543) + $_size546 = 0; + $_etype549 = 0; + $xfer += $input->readSetBegin($_etype549, $_size546); + for ($_i550 = 0; $_i550 < $_size546; ++$_i550) { - $elem544 = null; - $xfer += $input->readI64($elem544); - if (is_scalar($elem544)) { - $this->aborted[$elem544] = true; + $elem551 = null; + $xfer += $input->readI64($elem551); + if (is_scalar($elem551)) { + $this->aborted[$elem551] = true; } else { - $this->aborted []= $elem544; + $this->aborted []= $elem551; } } $xfer += $input->readSetEnd(); @@ -16778,17 +17046,17 @@ class HeartbeatTxnRangeResponse { case 2: if ($ftype == TType::SET) { $this->nosuch = array(); - $_size545 = 0; - $_etype548 = 0; - $xfer += $input->readSetBegin($_etype548, $_size545); - for ($_i549 = 0; $_i549 < $_size545; ++$_i549) + $_size552 = 0; + $_etype555 = 0; + $xfer += $input->readSetBegin($_etype555, $_size552); + for ($_i556 = 0; $_i556 < $_size552; ++$_i556) { - $elem550 = null; - $xfer += $input->readI64($elem550); - if (is_scalar($elem550)) { - $this->nosuch[$elem550] = true; + $elem557 = null; + $xfer += $input->readI64($elem557); + if (is_scalar($elem557)) { + $this->nosuch[$elem557] = true; } else { - $this->nosuch []= $elem550; + $this->nosuch []= $elem557; } } $xfer += $input->readSetEnd(); @@ -16817,12 +17085,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->aborted)); { - foreach ($this->aborted as $iter551 => $iter552) + foreach ($this->aborted as $iter558 => $iter559) { - if (is_scalar($iter552)) { - $xfer += $output->writeI64($iter551); + if (is_scalar($iter559)) { + $xfer += $output->writeI64($iter558); } else { - $xfer += $output->writeI64($iter552); + $xfer += $output->writeI64($iter559); } } } @@ -16838,12 +17106,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->nosuch)); { - foreach ($this->nosuch as $iter553 => $iter554) + foreach ($this->nosuch as $iter560 => $iter561) { - if (is_scalar($iter554)) { - $xfer += $output->writeI64($iter553); + if (is_scalar($iter561)) { + $xfer += $output->writeI64($iter560); } else { - $xfer += $output->writeI64($iter554); + $xfer += $output->writeI64($iter561); } } } @@ -17002,17 +17270,17 @@ class CompactionRequest { case 6: if ($ftype == TType::MAP) { $this->properties = array(); - $_size555 = 0; - $_ktype556 = 0; - $_vtype557 = 0; - $xfer += $input->readMapBegin($_ktype556, $_vtype557, $_size555); - for ($_i559 = 0; $_i559 < $_size555; ++$_i559) + $_size562 = 0; + $_ktype563 = 0; + $_vtype564 = 0; + $xfer += $input->readMapBegin($_ktype563, $_vtype564, $_size562); + for ($_i566 = 0; $_i566 < $_size562; ++$_i566) { - $key560 = ''; - $val561 = ''; - $xfer += $input->readString($key560); - $xfer += $input->readString($val561); - $this->properties[$key560] = $val561; + $key567 = ''; + $val568 = ''; + $xfer += $input->readString($key567); + $xfer += $input->readString($val568); + $this->properties[$key567] = $val568; } $xfer += $input->readMapEnd(); } else { @@ -17065,10 +17333,10 @@ class CompactionRequest { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->properties)); { - foreach ($this->properties as $kiter562 => $viter563) + foreach ($this->properties as $kiter569 => $viter570) { - $xfer += $output->writeString($kiter562); - $xfer += $output->writeString($viter563); + $xfer += $output->writeString($kiter569); + $xfer += $output->writeString($viter570); } } $output->writeMapEnd(); @@ -17655,15 +17923,15 @@ class ShowCompactResponse { case 1: if ($ftype == TType::LST) { $this->compacts = array(); - $_size564 = 0; - $_etype567 = 0; - $xfer += $input->readListBegin($_etype567, $_size564); - for ($_i568 = 0; $_i568 < $_size564; ++$_i568) + $_size571 = 0; + $_etype574 = 0; + $xfer += $input->readListBegin($_etype574, $_size571); + for ($_i575 = 0; $_i575 < $_size571; ++$_i575) { - $elem569 = null; - $elem569 = new \metastore\ShowCompactResponseElement(); - $xfer += $elem569->read($input); - $this->compacts []= $elem569; + $elem576 = null; + $elem576 = new \metastore\ShowCompactResponseElement(); + $xfer += $elem576->read($input); + $this->compacts []= $elem576; } $xfer += $input->readListEnd(); } else { @@ -17691,9 +17959,9 @@ class ShowCompactResponse { { $output->writeListBegin(TType::STRUCT, count($this->compacts)); { - foreach ($this->compacts as $iter570) + foreach ($this->compacts as $iter577) { - $xfer += $iter570->write($output); + $xfer += $iter577->write($output); } } $output->writeListEnd(); @@ -17840,14 +18108,14 @@ class AddDynamicPartitions { case 5: if ($ftype == TType::LST) { $this->partitionnames = array(); - $_size571 = 0; - $_etype574 = 0; - $xfer += $input->readListBegin($_etype574, $_size571); - for ($_i575 = 0; $_i575 < $_size571; ++$_i575) + $_size578 = 0; + $_etype581 = 0; + $xfer += $input->readListBegin($_etype581, $_size578); + for ($_i582 = 0; $_i582 < $_size578; ++$_i582) { - $elem576 = null; - $xfer += $input->readString($elem576); - $this->partitionnames []= $elem576; + $elem583 = null; + $xfer += $input->readString($elem583); + $this->partitionnames []= $elem583; } $xfer += $input->readListEnd(); } else { @@ -17902,9 +18170,9 @@ class AddDynamicPartitions { { $output->writeListBegin(TType::STRING, count($this->partitionnames)); { - foreach ($this->partitionnames as $iter577) + foreach ($this->partitionnames as $iter584) { - $xfer += $output->writeString($iter577); + $xfer += $output->writeString($iter584); } } $output->writeListEnd(); @@ -18210,17 +18478,17 @@ class CreationMetadata { case 3: if ($ftype == TType::SET) { $this->tablesUsed = array(); - $_size578 = 0; - $_etype581 = 0; - $xfer += $input->readSetBegin($_etype581, $_size578); - for ($_i582 = 0; $_i582 < $_size578; ++$_i582) + $_size585 = 0; + $_etype588 = 0; + $xfer += $input->readSetBegin($_etype588, $_size585); + for ($_i589 = 0; $_i589 < $_size585; ++$_i589) { - $elem583 = null; - $xfer += $input->readString($elem583); - if (is_scalar($elem583)) { - $this->tablesUsed[$elem583] = true; + $elem590 = null; + $xfer += $input->readString($elem590); + if (is_scalar($elem590)) { + $this->tablesUsed[$elem590] = true; } else { - $this->tablesUsed []= $elem583; + $this->tablesUsed []= $elem590; } } $xfer += $input->readSetEnd(); @@ -18266,12 +18534,12 @@ class CreationMetadata { { $output->writeSetBegin(TType::STRING, count($this->tablesUsed)); { - foreach ($this->tablesUsed as $iter584 => $iter585) + foreach ($this->tablesUsed as $iter591 => $iter592) { - if (is_scalar($iter585)) { - $xfer += $output->writeString($iter584); + if (is_scalar($iter592)) { + $xfer += $output->writeString($iter591); } else { - $xfer += $output->writeString($iter585); + $xfer += $output->writeString($iter592); } } } @@ -18653,15 +18921,15 @@ class NotificationEventResponse { case 1: if ($ftype == TType::LST) { $this->events = array(); - $_size586 = 0; - $_etype589 = 0; - $xfer += $input->readListBegin($_etype589, $_size586); - for ($_i590 = 0; $_i590 < $_size586; ++$_i590) + $_size593 = 0; + $_etype596 = 0; + $xfer += $input->readListBegin($_etype596, $_size593); + for ($_i597 = 0; $_i597 < $_size593; ++$_i597) { - $elem591 = null; - $elem591 = new \metastore\NotificationEvent(); - $xfer += $elem591->read($input); - $this->events []= $elem591; + $elem598 = null; + $elem598 = new \metastore\NotificationEvent(); + $xfer += $elem598->read($input); + $this->events []= $elem598; } $xfer += $input->readListEnd(); } else { @@ -18689,9 +18957,9 @@ class NotificationEventResponse { { $output->writeListBegin(TType::STRUCT, count($this->events)); { - foreach ($this->events as $iter592) + foreach ($this->events as $iter599) { - $xfer += $iter592->write($output); + $xfer += $iter599->write($output); } } $output->writeListEnd(); @@ -19036,14 +19304,14 @@ class InsertEventRequestData { case 2: if ($ftype == TType::LST) { $this->filesAdded = array(); - $_size593 = 0; - $_etype596 = 0; - $xfer += $input->readListBegin($_etype596, $_size593); - for ($_i597 = 0; $_i597 < $_size593; ++$_i597) + $_size600 = 0; + $_etype603 = 0; + $xfer += $input->readListBegin($_etype603, $_size600); + for ($_i604 = 0; $_i604 < $_size600; ++$_i604) { - $elem598 = null; - $xfer += $input->readString($elem598); - $this->filesAdded []= $elem598; + $elem605 = null; + $xfer += $input->readString($elem605); + $this->filesAdded []= $elem605; } $xfer += $input->readListEnd(); } else { @@ -19053,14 +19321,14 @@ class InsertEventRequestData { case 3: if ($ftype == TType::LST) { $this->filesAddedChecksum = array(); - $_size599 = 0; - $_etype602 = 0; - $xfer += $input->readListBegin($_etype602, $_size599); - for ($_i603 = 0; $_i603 < $_size599; ++$_i603) + $_size606 = 0; + $_etype609 = 0; + $xfer += $input->readListBegin($_etype609, $_size606); + for ($_i610 = 0; $_i610 < $_size606; ++$_i610) { - $elem604 = null; - $xfer += $input->readString($elem604); - $this->filesAddedChecksum []= $elem604; + $elem611 = null; + $xfer += $input->readString($elem611); + $this->filesAddedChecksum []= $elem611; } $xfer += $input->readListEnd(); } else { @@ -19093,9 +19361,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAdded)); { - foreach ($this->filesAdded as $iter605) + foreach ($this->filesAdded as $iter612) { - $xfer += $output->writeString($iter605); + $xfer += $output->writeString($iter612); } } $output->writeListEnd(); @@ -19110,9 +19378,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAddedChecksum)); { - foreach ($this->filesAddedChecksum as $iter606) + foreach ($this->filesAddedChecksum as $iter613) { - $xfer += $output->writeString($iter606); + $xfer += $output->writeString($iter613); } } $output->writeListEnd(); @@ -19330,14 +19598,14 @@ class FireEventRequest { case 5: if ($ftype == TType::LST) { $this->partitionVals = array(); - $_size607 = 0; - $_etype610 = 0; - $xfer += $input->readListBegin($_etype610, $_size607); - for ($_i611 = 0; $_i611 < $_size607; ++$_i611) + $_size614 = 0; + $_etype617 = 0; + $xfer += $input->readListBegin($_etype617, $_size614); + for ($_i618 = 0; $_i618 < $_size614; ++$_i618) { - $elem612 = null; - $xfer += $input->readString($elem612); - $this->partitionVals []= $elem612; + $elem619 = null; + $xfer += $input->readString($elem619); + $this->partitionVals []= $elem619; } $xfer += $input->readListEnd(); } else { @@ -19388,9 +19656,9 @@ class FireEventRequest { { $output->writeListBegin(TType::STRING, count($this->partitionVals)); { - foreach ($this->partitionVals as $iter613) + foreach ($this->partitionVals as $iter620) { - $xfer += $output->writeString($iter613); + $xfer += $output->writeString($iter620); } } $output->writeListEnd(); @@ -19618,18 +19886,18 @@ class GetFileMetadataByExprResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size614 = 0; - $_ktype615 = 0; - $_vtype616 = 0; - $xfer += $input->readMapBegin($_ktype615, $_vtype616, $_size614); - for ($_i618 = 0; $_i618 < $_size614; ++$_i618) + $_size621 = 0; + $_ktype622 = 0; + $_vtype623 = 0; + $xfer += $input->readMapBegin($_ktype622, $_vtype623, $_size621); + for ($_i625 = 0; $_i625 < $_size621; ++$_i625) { - $key619 = 0; - $val620 = new \metastore\MetadataPpdResult(); - $xfer += $input->readI64($key619); - $val620 = new \metastore\MetadataPpdResult(); - $xfer += $val620->read($input); - $this->metadata[$key619] = $val620; + $key626 = 0; + $val627 = new \metastore\MetadataPpdResult(); + $xfer += $input->readI64($key626); + $val627 = new \metastore\MetadataPpdResult(); + $xfer += $val627->read($input); + $this->metadata[$key626] = $val627; } $xfer += $input->readMapEnd(); } else { @@ -19664,10 +19932,10 @@ class GetFileMetadataByExprResult { { $output->writeMapBegin(TType::I64, TType::STRUCT, count($this->metadata)); { - foreach ($this->metadata as $kiter621 => $viter622) + foreach ($this->metadata as $kiter628 => $viter629) { - $xfer += $output->writeI64($kiter621); - $xfer += $viter622->write($output); + $xfer += $output->writeI64($kiter628); + $xfer += $viter629->write($output); } } $output->writeMapEnd(); @@ -19769,14 +20037,14 @@ class GetFileMetadataByExprRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size623 = 0; - $_etype626 = 0; - $xfer += $input->readListBegin($_etype626, $_size623); - for ($_i627 = 0; $_i627 < $_size623; ++$_i627) + $_size630 = 0; + $_etype633 = 0; + $xfer += $input->readListBegin($_etype633, $_size630); + for ($_i634 = 0; $_i634 < $_size630; ++$_i634) { - $elem628 = null; - $xfer += $input->readI64($elem628); - $this->fileIds []= $elem628; + $elem635 = null; + $xfer += $input->readI64($elem635); + $this->fileIds []= $elem635; } $xfer += $input->readListEnd(); } else { @@ -19825,9 +20093,9 @@ class GetFileMetadataByExprRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter629) + foreach ($this->fileIds as $iter636) { - $xfer += $output->writeI64($iter629); + $xfer += $output->writeI64($iter636); } } $output->writeListEnd(); @@ -19921,17 +20189,17 @@ class GetFileMetadataResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size630 = 0; - $_ktype631 = 0; - $_vtype632 = 0; - $xfer += $input->readMapBegin($_ktype631, $_vtype632, $_size630); - for ($_i634 = 0; $_i634 < $_size630; ++$_i634) + $_size637 = 0; + $_ktype638 = 0; + $_vtype639 = 0; + $xfer += $input->readMapBegin($_ktype638, $_vtype639, $_size637); + for ($_i641 = 0; $_i641 < $_size637; ++$_i641) { - $key635 = 0; - $val636 = ''; - $xfer += $input->readI64($key635); - $xfer += $input->readString($val636); - $this->metadata[$key635] = $val636; + $key642 = 0; + $val643 = ''; + $xfer += $input->readI64($key642); + $xfer += $input->readString($val643); + $this->metadata[$key642] = $val643; } $xfer += $input->readMapEnd(); } else { @@ -19966,10 +20234,10 @@ class GetFileMetadataResult { { $output->writeMapBegin(TType::I64, TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $kiter637 => $viter638) + foreach ($this->metadata as $kiter644 => $viter645) { - $xfer += $output->writeI64($kiter637); - $xfer += $output->writeString($viter638); + $xfer += $output->writeI64($kiter644); + $xfer += $output->writeString($viter645); } } $output->writeMapEnd(); @@ -20038,14 +20306,14 @@ class GetFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size639 = 0; - $_etype642 = 0; - $xfer += $input->readListBegin($_etype642, $_size639); - for ($_i643 = 0; $_i643 < $_size639; ++$_i643) + $_size646 = 0; + $_etype649 = 0; + $xfer += $input->readListBegin($_etype649, $_size646); + for ($_i650 = 0; $_i650 < $_size646; ++$_i650) { - $elem644 = null; - $xfer += $input->readI64($elem644); - $this->fileIds []= $elem644; + $elem651 = null; + $xfer += $input->readI64($elem651); + $this->fileIds []= $elem651; } $xfer += $input->readListEnd(); } else { @@ -20073,9 +20341,9 @@ class GetFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter645) + foreach ($this->fileIds as $iter652) { - $xfer += $output->writeI64($iter645); + $xfer += $output->writeI64($iter652); } } $output->writeListEnd(); @@ -20215,14 +20483,14 @@ class PutFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size646 = 0; - $_etype649 = 0; - $xfer += $input->readListBegin($_etype649, $_size646); - for ($_i650 = 0; $_i650 < $_size646; ++$_i650) + $_size653 = 0; + $_etype656 = 0; + $xfer += $input->readListBegin($_etype656, $_size653); + for ($_i657 = 0; $_i657 < $_size653; ++$_i657) { - $elem651 = null; - $xfer += $input->readI64($elem651); - $this->fileIds []= $elem651; + $elem658 = null; + $xfer += $input->readI64($elem658); + $this->fileIds []= $elem658; } $xfer += $input->readListEnd(); } else { @@ -20232,14 +20500,14 @@ class PutFileMetadataRequest { case 2: if ($ftype == TType::LST) { $this->metadata = array(); - $_size652 = 0; - $_etype655 = 0; - $xfer += $input->readListBegin($_etype655, $_size652); - for ($_i656 = 0; $_i656 < $_size652; ++$_i656) + $_size659 = 0; + $_etype662 = 0; + $xfer += $input->readListBegin($_etype662, $_size659); + for ($_i663 = 0; $_i663 < $_size659; ++$_i663) { - $elem657 = null; - $xfer += $input->readString($elem657); - $this->metadata []= $elem657; + $elem664 = null; + $xfer += $input->readString($elem664); + $this->metadata []= $elem664; } $xfer += $input->readListEnd(); } else { @@ -20274,9 +20542,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter658) + foreach ($this->fileIds as $iter665) { - $xfer += $output->writeI64($iter658); + $xfer += $output->writeI64($iter665); } } $output->writeListEnd(); @@ -20291,9 +20559,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $iter659) + foreach ($this->metadata as $iter666) { - $xfer += $output->writeString($iter659); + $xfer += $output->writeString($iter666); } } $output->writeListEnd(); @@ -20412,14 +20680,14 @@ class ClearFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size660 = 0; - $_etype663 = 0; - $xfer += $input->readListBegin($_etype663, $_size660); - for ($_i664 = 0; $_i664 < $_size660; ++$_i664) + $_size667 = 0; + $_etype670 = 0; + $xfer += $input->readListBegin($_etype670, $_size667); + for ($_i671 = 0; $_i671 < $_size667; ++$_i671) { - $elem665 = null; - $xfer += $input->readI64($elem665); - $this->fileIds []= $elem665; + $elem672 = null; + $xfer += $input->readI64($elem672); + $this->fileIds []= $elem672; } $xfer += $input->readListEnd(); } else { @@ -20447,9 +20715,9 @@ class ClearFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter666) + foreach ($this->fileIds as $iter673) { - $xfer += $output->writeI64($iter666); + $xfer += $output->writeI64($iter673); } } $output->writeListEnd(); @@ -20733,15 +21001,15 @@ class GetAllFunctionsResponse { case 1: if ($ftype == TType::LST) { $this->functions = array(); - $_size667 = 0; - $_etype670 = 0; - $xfer += $input->readListBegin($_etype670, $_size667); - for ($_i671 = 0; $_i671 < $_size667; ++$_i671) + $_size674 = 0; + $_etype677 = 0; + $xfer += $input->readListBegin($_etype677, $_size674); + for ($_i678 = 0; $_i678 < $_size674; ++$_i678) { - $elem672 = null; - $elem672 = new \metastore\Function(); - $xfer += $elem672->read($input); - $this->functions []= $elem672; + $elem679 = null; + $elem679 = new \metastore\Function(); + $xfer += $elem679->read($input); + $this->functions []= $elem679; } $xfer += $input->readListEnd(); } else { @@ -20769,9 +21037,9 @@ class GetAllFunctionsResponse { { $output->writeListBegin(TType::STRUCT, count($this->functions)); { - foreach ($this->functions as $iter673) + foreach ($this->functions as $iter680) { - $xfer += $iter673->write($output); + $xfer += $iter680->write($output); } } $output->writeListEnd(); @@ -20835,14 +21103,14 @@ class ClientCapabilities { case 1: if ($ftype == TType::LST) { $this->values = array(); - $_size674 = 0; - $_etype677 = 0; - $xfer += $input->readListBegin($_etype677, $_size674); - for ($_i678 = 0; $_i678 < $_size674; ++$_i678) + $_size681 = 0; + $_etype684 = 0; + $xfer += $input->readListBegin($_etype684, $_size681); + for ($_i685 = 0; $_i685 < $_size681; ++$_i685) { - $elem679 = null; - $xfer += $input->readI32($elem679); - $this->values []= $elem679; + $elem686 = null; + $xfer += $input->readI32($elem686); + $this->values []= $elem686; } $xfer += $input->readListEnd(); } else { @@ -20870,9 +21138,9 @@ class ClientCapabilities { { $output->writeListBegin(TType::I32, count($this->values)); { - foreach ($this->values as $iter680) + foreach ($this->values as $iter687) { - $xfer += $output->writeI32($iter680); + $xfer += $output->writeI32($iter687); } } $output->writeListEnd(); @@ -21172,14 +21440,14 @@ class GetTablesRequest { case 2: if ($ftype == TType::LST) { $this->tblNames = array(); - $_size681 = 0; - $_etype684 = 0; - $xfer += $input->readListBegin($_etype684, $_size681); - for ($_i685 = 0; $_i685 < $_size681; ++$_i685) + $_size688 = 0; + $_etype691 = 0; + $xfer += $input->readListBegin($_etype691, $_size688); + for ($_i692 = 0; $_i692 < $_size688; ++$_i692) { - $elem686 = null; - $xfer += $input->readString($elem686); - $this->tblNames []= $elem686; + $elem693 = null; + $xfer += $input->readString($elem693); + $this->tblNames []= $elem693; } $xfer += $input->readListEnd(); } else { @@ -21220,9 +21488,9 @@ class GetTablesRequest { { $output->writeListBegin(TType::STRING, count($this->tblNames)); { - foreach ($this->tblNames as $iter687) + foreach ($this->tblNames as $iter694) { - $xfer += $output->writeString($iter687); + $xfer += $output->writeString($iter694); } } $output->writeListEnd(); @@ -21295,15 +21563,15 @@ class GetTablesResult { case 1: if ($ftype == TType::LST) { $this->tables = array(); - $_size688 = 0; - $_etype691 = 0; - $xfer += $input->readListBegin($_etype691, $_size688); - for ($_i692 = 0; $_i692 < $_size688; ++$_i692) + $_size695 = 0; + $_etype698 = 0; + $xfer += $input->readListBegin($_etype698, $_size695); + for ($_i699 = 0; $_i699 < $_size695; ++$_i699) { - $elem693 = null; - $elem693 = new \metastore\Table(); - $xfer += $elem693->read($input); - $this->tables []= $elem693; + $elem700 = null; + $elem700 = new \metastore\Table(); + $xfer += $elem700->read($input); + $this->tables []= $elem700; } $xfer += $input->readListEnd(); } else { @@ -21331,9 +21599,9 @@ class GetTablesResult { { $output->writeListBegin(TType::STRUCT, count($this->tables)); { - foreach ($this->tables as $iter694) + foreach ($this->tables as $iter701) { - $xfer += $iter694->write($output); + $xfer += $iter701->write($output); } } $output->writeListEnd(); @@ -21711,17 +21979,17 @@ class Materialization { case 1: if ($ftype == TType::SET) { $this->tablesUsed = array(); - $_size695 = 0; - $_etype698 = 0; - $xfer += $input->readSetBegin($_etype698, $_size695); - for ($_i699 = 0; $_i699 < $_size695; ++$_i699) + $_size702 = 0; + $_etype705 = 0; + $xfer += $input->readSetBegin($_etype705, $_size702); + for ($_i706 = 0; $_i706 < $_size702; ++$_i706) { - $elem700 = null; - $xfer += $input->readString($elem700); - if (is_scalar($elem700)) { - $this->tablesUsed[$elem700] = true; + $elem707 = null; + $xfer += $input->readString($elem707); + if (is_scalar($elem707)) { + $this->tablesUsed[$elem707] = true; } else { - $this->tablesUsed []= $elem700; + $this->tablesUsed []= $elem707; } } $xfer += $input->readSetEnd(); @@ -21764,12 +22032,12 @@ class Materialization { { $output->writeSetBegin(TType::STRING, count($this->tablesUsed)); { - foreach ($this->tablesUsed as $iter701 => $iter702) + foreach ($this->tablesUsed as $iter708 => $iter709) { - if (is_scalar($iter702)) { - $xfer += $output->writeString($iter701); + if (is_scalar($iter709)) { + $xfer += $output->writeString($iter708); } else { - $xfer += $output->writeString($iter702); + $xfer += $output->writeString($iter709); } } } @@ -23036,15 +23304,15 @@ class WMFullResourcePlan { case 2: if ($ftype == TType::LST) { $this->pools = array(); - $_size703 = 0; - $_etype706 = 0; - $xfer += $input->readListBegin($_etype706, $_size703); - for ($_i707 = 0; $_i707 < $_size703; ++$_i707) + $_size710 = 0; + $_etype713 = 0; + $xfer += $input->readListBegin($_etype713, $_size710); + for ($_i714 = 0; $_i714 < $_size710; ++$_i714) { - $elem708 = null; - $elem708 = new \metastore\WMPool(); - $xfer += $elem708->read($input); - $this->pools []= $elem708; + $elem715 = null; + $elem715 = new \metastore\WMPool(); + $xfer += $elem715->read($input); + $this->pools []= $elem715; } $xfer += $input->readListEnd(); } else { @@ -23054,15 +23322,15 @@ class WMFullResourcePlan { case 3: if ($ftype == TType::LST) { $this->mappings = array(); - $_size709 = 0; - $_etype712 = 0; - $xfer += $input->readListBegin($_etype712, $_size709); - for ($_i713 = 0; $_i713 < $_size709; ++$_i713) + $_size716 = 0; + $_etype719 = 0; + $xfer += $input->readListBegin($_etype719, $_size716); + for ($_i720 = 0; $_i720 < $_size716; ++$_i720) { - $elem714 = null; - $elem714 = new \metastore\WMMapping(); - $xfer += $elem714->read($input); - $this->mappings []= $elem714; + $elem721 = null; + $elem721 = new \metastore\WMMapping(); + $xfer += $elem721->read($input); + $this->mappings []= $elem721; } $xfer += $input->readListEnd(); } else { @@ -23072,15 +23340,15 @@ class WMFullResourcePlan { case 4: if ($ftype == TType::LST) { $this->triggers = array(); - $_size715 = 0; - $_etype718 = 0; - $xfer += $input->readListBegin($_etype718, $_size715); - for ($_i719 = 0; $_i719 < $_size715; ++$_i719) + $_size722 = 0; + $_etype725 = 0; + $xfer += $input->readListBegin($_etype725, $_size722); + for ($_i726 = 0; $_i726 < $_size722; ++$_i726) { - $elem720 = null; - $elem720 = new \metastore\WMTrigger(); - $xfer += $elem720->read($input); - $this->triggers []= $elem720; + $elem727 = null; + $elem727 = new \metastore\WMTrigger(); + $xfer += $elem727->read($input); + $this->triggers []= $elem727; } $xfer += $input->readListEnd(); } else { @@ -23090,15 +23358,15 @@ class WMFullResourcePlan { case 5: if ($ftype == TType::LST) { $this->poolTriggers = array(); - $_size721 = 0; - $_etype724 = 0; - $xfer += $input->readListBegin($_etype724, $_size721); - for ($_i725 = 0; $_i725 < $_size721; ++$_i725) + $_size728 = 0; + $_etype731 = 0; + $xfer += $input->readListBegin($_etype731, $_size728); + for ($_i732 = 0; $_i732 < $_size728; ++$_i732) { - $elem726 = null; - $elem726 = new \metastore\WMPoolTrigger(); - $xfer += $elem726->read($input); - $this->poolTriggers []= $elem726; + $elem733 = null; + $elem733 = new \metastore\WMPoolTrigger(); + $xfer += $elem733->read($input); + $this->poolTriggers []= $elem733; } $xfer += $input->readListEnd(); } else { @@ -23134,9 +23402,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->pools)); { - foreach ($this->pools as $iter727) + foreach ($this->pools as $iter734) { - $xfer += $iter727->write($output); + $xfer += $iter734->write($output); } } $output->writeListEnd(); @@ -23151,9 +23419,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->mappings)); { - foreach ($this->mappings as $iter728) + foreach ($this->mappings as $iter735) { - $xfer += $iter728->write($output); + $xfer += $iter735->write($output); } } $output->writeListEnd(); @@ -23168,9 +23436,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->triggers)); { - foreach ($this->triggers as $iter729) + foreach ($this->triggers as $iter736) { - $xfer += $iter729->write($output); + $xfer += $iter736->write($output); } } $output->writeListEnd(); @@ -23185,9 +23453,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->poolTriggers)); { - foreach ($this->poolTriggers as $iter730) + foreach ($this->poolTriggers as $iter737) { - $xfer += $iter730->write($output); + $xfer += $iter737->write($output); } } $output->writeListEnd(); @@ -23740,15 +24008,15 @@ class WMGetAllResourcePlanResponse { case 1: if ($ftype == TType::LST) { $this->resourcePlans = array(); - $_size731 = 0; - $_etype734 = 0; - $xfer += $input->readListBegin($_etype734, $_size731); - for ($_i735 = 0; $_i735 < $_size731; ++$_i735) + $_size738 = 0; + $_etype741 = 0; + $xfer += $input->readListBegin($_etype741, $_size738); + for ($_i742 = 0; $_i742 < $_size738; ++$_i742) { - $elem736 = null; - $elem736 = new \metastore\WMResourcePlan(); - $xfer += $elem736->read($input); - $this->resourcePlans []= $elem736; + $elem743 = null; + $elem743 = new \metastore\WMResourcePlan(); + $xfer += $elem743->read($input); + $this->resourcePlans []= $elem743; } $xfer += $input->readListEnd(); } else { @@ -23776,9 +24044,9 @@ class WMGetAllResourcePlanResponse { { $output->writeListBegin(TType::STRUCT, count($this->resourcePlans)); { - foreach ($this->resourcePlans as $iter737) + foreach ($this->resourcePlans as $iter744) { - $xfer += $iter737->write($output); + $xfer += $iter744->write($output); } } $output->writeListEnd(); @@ -24184,14 +24452,14 @@ class WMValidateResourcePlanResponse { case 1: if ($ftype == TType::LST) { $this->errors = array(); - $_size738 = 0; - $_etype741 = 0; - $xfer += $input->readListBegin($_etype741, $_size738); - for ($_i742 = 0; $_i742 < $_size738; ++$_i742) + $_size745 = 0; + $_etype748 = 0; + $xfer += $input->readListBegin($_etype748, $_size745); + for ($_i749 = 0; $_i749 < $_size745; ++$_i749) { - $elem743 = null; - $xfer += $input->readString($elem743); - $this->errors []= $elem743; + $elem750 = null; + $xfer += $input->readString($elem750); + $this->errors []= $elem750; } $xfer += $input->readListEnd(); } else { @@ -24201,14 +24469,14 @@ class WMValidateResourcePlanResponse { case 2: if ($ftype == TType::LST) { $this->warnings = array(); - $_size744 = 0; - $_etype747 = 0; - $xfer += $input->readListBegin($_etype747, $_size744); - for ($_i748 = 0; $_i748 < $_size744; ++$_i748) + $_size751 = 0; + $_etype754 = 0; + $xfer += $input->readListBegin($_etype754, $_size751); + for ($_i755 = 0; $_i755 < $_size751; ++$_i755) { - $elem749 = null; - $xfer += $input->readString($elem749); - $this->warnings []= $elem749; + $elem756 = null; + $xfer += $input->readString($elem756); + $this->warnings []= $elem756; } $xfer += $input->readListEnd(); } else { @@ -24236,9 +24504,9 @@ class WMValidateResourcePlanResponse { { $output->writeListBegin(TType::STRING, count($this->errors)); { - foreach ($this->errors as $iter750) + foreach ($this->errors as $iter757) { - $xfer += $output->writeString($iter750); + $xfer += $output->writeString($iter757); } } $output->writeListEnd(); @@ -24253,9 +24521,9 @@ class WMValidateResourcePlanResponse { { $output->writeListBegin(TType::STRING, count($this->warnings)); { - foreach ($this->warnings as $iter751) + foreach ($this->warnings as $iter758) { - $xfer += $output->writeString($iter751); + $xfer += $output->writeString($iter758); } } $output->writeListEnd(); @@ -24928,15 +25196,15 @@ class WMGetTriggersForResourePlanResponse { case 1: if ($ftype == TType::LST) { $this->triggers = array(); - $_size752 = 0; - $_etype755 = 0; - $xfer += $input->readListBegin($_etype755, $_size752); - for ($_i756 = 0; $_i756 < $_size752; ++$_i756) + $_size759 = 0; + $_etype762 = 0; + $xfer += $input->readListBegin($_etype762, $_size759); + for ($_i763 = 0; $_i763 < $_size759; ++$_i763) { - $elem757 = null; - $elem757 = new \metastore\WMTrigger(); - $xfer += $elem757->read($input); - $this->triggers []= $elem757; + $elem764 = null; + $elem764 = new \metastore\WMTrigger(); + $xfer += $elem764->read($input); + $this->triggers []= $elem764; } $xfer += $input->readListEnd(); } else { @@ -24964,9 +25232,9 @@ class WMGetTriggersForResourePlanResponse { { $output->writeListBegin(TType::STRUCT, count($this->triggers)); { - foreach ($this->triggers as $iter758) + foreach ($this->triggers as $iter765) { - $xfer += $iter758->write($output); + $xfer += $iter765->write($output); } } $output->writeListEnd(); diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index dfddd4a7c9..d2b0896d2f 100644 --- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -13728,10 +13728,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype758, _size755) = iprot.readListBegin() - for _i759 in xrange(_size755): - _elem760 = iprot.readString() - self.success.append(_elem760) + (_etype765, _size762) = iprot.readListBegin() + for _i766 in xrange(_size762): + _elem767 = iprot.readString() + self.success.append(_elem767) iprot.readListEnd() else: iprot.skip(ftype) @@ -13754,8 +13754,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter761 in self.success: - oprot.writeString(iter761) + for iter768 in self.success: + oprot.writeString(iter768) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13860,10 +13860,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype765, _size762) = iprot.readListBegin() - for _i766 in xrange(_size762): - _elem767 = iprot.readString() - self.success.append(_elem767) + (_etype772, _size769) = iprot.readListBegin() + for _i773 in xrange(_size769): + _elem774 = iprot.readString() + self.success.append(_elem774) iprot.readListEnd() else: iprot.skip(ftype) @@ -13886,8 +13886,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter768 in self.success: - oprot.writeString(iter768) + for iter775 in self.success: + oprot.writeString(iter775) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14657,12 +14657,12 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype770, _vtype771, _size769 ) = iprot.readMapBegin() - for _i773 in xrange(_size769): - _key774 = iprot.readString() - _val775 = Type() - _val775.read(iprot) - self.success[_key774] = _val775 + (_ktype777, _vtype778, _size776 ) = iprot.readMapBegin() + for _i780 in xrange(_size776): + _key781 = iprot.readString() + _val782 = Type() + _val782.read(iprot) + self.success[_key781] = _val782 iprot.readMapEnd() else: iprot.skip(ftype) @@ -14685,9 +14685,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success)) - for kiter776,viter777 in self.success.items(): - oprot.writeString(kiter776) - viter777.write(oprot) + for kiter783,viter784 in self.success.items(): + oprot.writeString(kiter783) + viter784.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -14830,11 +14830,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype781, _size778) = iprot.readListBegin() - for _i782 in xrange(_size778): - _elem783 = FieldSchema() - _elem783.read(iprot) - self.success.append(_elem783) + (_etype788, _size785) = iprot.readListBegin() + for _i789 in xrange(_size785): + _elem790 = FieldSchema() + _elem790.read(iprot) + self.success.append(_elem790) iprot.readListEnd() else: iprot.skip(ftype) @@ -14869,8 +14869,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter784 in self.success: - iter784.write(oprot) + for iter791 in self.success: + iter791.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15037,11 +15037,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype788, _size785) = iprot.readListBegin() - for _i789 in xrange(_size785): - _elem790 = FieldSchema() - _elem790.read(iprot) - self.success.append(_elem790) + (_etype795, _size792) = iprot.readListBegin() + for _i796 in xrange(_size792): + _elem797 = FieldSchema() + _elem797.read(iprot) + self.success.append(_elem797) iprot.readListEnd() else: iprot.skip(ftype) @@ -15076,8 +15076,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter791 in self.success: - iter791.write(oprot) + for iter798 in self.success: + iter798.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15230,11 +15230,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype795, _size792) = iprot.readListBegin() - for _i796 in xrange(_size792): - _elem797 = FieldSchema() - _elem797.read(iprot) - self.success.append(_elem797) + (_etype802, _size799) = iprot.readListBegin() + for _i803 in xrange(_size799): + _elem804 = FieldSchema() + _elem804.read(iprot) + self.success.append(_elem804) iprot.readListEnd() else: iprot.skip(ftype) @@ -15269,8 +15269,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter798 in self.success: - iter798.write(oprot) + for iter805 in self.success: + iter805.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15437,11 +15437,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype802, _size799) = iprot.readListBegin() - for _i803 in xrange(_size799): - _elem804 = FieldSchema() - _elem804.read(iprot) - self.success.append(_elem804) + (_etype809, _size806) = iprot.readListBegin() + for _i810 in xrange(_size806): + _elem811 = FieldSchema() + _elem811.read(iprot) + self.success.append(_elem811) iprot.readListEnd() else: iprot.skip(ftype) @@ -15476,8 +15476,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter805 in self.success: - iter805.write(oprot) + for iter812 in self.success: + iter812.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15924,44 +15924,44 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.primaryKeys = [] - (_etype809, _size806) = iprot.readListBegin() - for _i810 in xrange(_size806): - _elem811 = SQLPrimaryKey() - _elem811.read(iprot) - self.primaryKeys.append(_elem811) + (_etype816, _size813) = iprot.readListBegin() + for _i817 in xrange(_size813): + _elem818 = SQLPrimaryKey() + _elem818.read(iprot) + self.primaryKeys.append(_elem818) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.foreignKeys = [] - (_etype815, _size812) = iprot.readListBegin() - for _i816 in xrange(_size812): - _elem817 = SQLForeignKey() - _elem817.read(iprot) - self.foreignKeys.append(_elem817) + (_etype822, _size819) = iprot.readListBegin() + for _i823 in xrange(_size819): + _elem824 = SQLForeignKey() + _elem824.read(iprot) + self.foreignKeys.append(_elem824) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.uniqueConstraints = [] - (_etype821, _size818) = iprot.readListBegin() - for _i822 in xrange(_size818): - _elem823 = SQLUniqueConstraint() - _elem823.read(iprot) - self.uniqueConstraints.append(_elem823) + (_etype828, _size825) = iprot.readListBegin() + for _i829 in xrange(_size825): + _elem830 = SQLUniqueConstraint() + _elem830.read(iprot) + self.uniqueConstraints.append(_elem830) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.notNullConstraints = [] - (_etype827, _size824) = iprot.readListBegin() - for _i828 in xrange(_size824): - _elem829 = SQLNotNullConstraint() - _elem829.read(iprot) - self.notNullConstraints.append(_elem829) + (_etype834, _size831) = iprot.readListBegin() + for _i835 in xrange(_size831): + _elem836 = SQLNotNullConstraint() + _elem836.read(iprot) + self.notNullConstraints.append(_elem836) iprot.readListEnd() else: iprot.skip(ftype) @@ -15982,29 +15982,29 @@ def write(self, oprot): if self.primaryKeys is not None: oprot.writeFieldBegin('primaryKeys', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys)) - for iter830 in self.primaryKeys: - iter830.write(oprot) + for iter837 in self.primaryKeys: + iter837.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.foreignKeys is not None: oprot.writeFieldBegin('foreignKeys', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.foreignKeys)) - for iter831 in self.foreignKeys: - iter831.write(oprot) + for iter838 in self.foreignKeys: + iter838.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.uniqueConstraints is not None: oprot.writeFieldBegin('uniqueConstraints', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.uniqueConstraints)) - for iter832 in self.uniqueConstraints: - iter832.write(oprot) + for iter839 in self.uniqueConstraints: + iter839.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.notNullConstraints is not None: oprot.writeFieldBegin('notNullConstraints', TType.LIST, 5) oprot.writeListBegin(TType.STRUCT, len(self.notNullConstraints)) - for iter833 in self.notNullConstraints: - iter833.write(oprot) + for iter840 in self.notNullConstraints: + iter840.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17270,10 +17270,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.partNames = [] - (_etype837, _size834) = iprot.readListBegin() - for _i838 in xrange(_size834): - _elem839 = iprot.readString() - self.partNames.append(_elem839) + (_etype844, _size841) = iprot.readListBegin() + for _i845 in xrange(_size841): + _elem846 = iprot.readString() + self.partNames.append(_elem846) iprot.readListEnd() else: iprot.skip(ftype) @@ -17298,8 +17298,8 @@ def write(self, oprot): if self.partNames is not None: oprot.writeFieldBegin('partNames', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.partNames)) - for iter840 in self.partNames: - oprot.writeString(iter840) + for iter847 in self.partNames: + oprot.writeString(iter847) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17499,10 +17499,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype844, _size841) = iprot.readListBegin() - for _i845 in xrange(_size841): - _elem846 = iprot.readString() - self.success.append(_elem846) + (_etype851, _size848) = iprot.readListBegin() + for _i852 in xrange(_size848): + _elem853 = iprot.readString() + self.success.append(_elem853) iprot.readListEnd() else: iprot.skip(ftype) @@ -17525,8 +17525,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter847 in self.success: - oprot.writeString(iter847) + for iter854 in self.success: + oprot.writeString(iter854) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17676,10 +17676,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype851, _size848) = iprot.readListBegin() - for _i852 in xrange(_size848): - _elem853 = iprot.readString() - self.success.append(_elem853) + (_etype858, _size855) = iprot.readListBegin() + for _i859 in xrange(_size855): + _elem860 = iprot.readString() + self.success.append(_elem860) iprot.readListEnd() else: iprot.skip(ftype) @@ -17702,8 +17702,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter854 in self.success: - oprot.writeString(iter854) + for iter861 in self.success: + oprot.writeString(iter861) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17827,10 +17827,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype858, _size855) = iprot.readListBegin() - for _i859 in xrange(_size855): - _elem860 = iprot.readString() - self.success.append(_elem860) + (_etype865, _size862) = iprot.readListBegin() + for _i866 in xrange(_size862): + _elem867 = iprot.readString() + self.success.append(_elem867) iprot.readListEnd() else: iprot.skip(ftype) @@ -17853,8 +17853,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter861 in self.success: - oprot.writeString(iter861) + for iter868 in self.success: + oprot.writeString(iter868) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17927,10 +17927,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.tbl_types = [] - (_etype865, _size862) = iprot.readListBegin() - for _i866 in xrange(_size862): - _elem867 = iprot.readString() - self.tbl_types.append(_elem867) + (_etype872, _size869) = iprot.readListBegin() + for _i873 in xrange(_size869): + _elem874 = iprot.readString() + self.tbl_types.append(_elem874) iprot.readListEnd() else: iprot.skip(ftype) @@ -17955,8 +17955,8 @@ def write(self, oprot): if self.tbl_types is not None: oprot.writeFieldBegin('tbl_types', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.tbl_types)) - for iter868 in self.tbl_types: - oprot.writeString(iter868) + for iter875 in self.tbl_types: + oprot.writeString(iter875) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18012,11 +18012,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype872, _size869) = iprot.readListBegin() - for _i873 in xrange(_size869): - _elem874 = TableMeta() - _elem874.read(iprot) - self.success.append(_elem874) + (_etype879, _size876) = iprot.readListBegin() + for _i880 in xrange(_size876): + _elem881 = TableMeta() + _elem881.read(iprot) + self.success.append(_elem881) iprot.readListEnd() else: iprot.skip(ftype) @@ -18039,8 +18039,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter875 in self.success: - iter875.write(oprot) + for iter882 in self.success: + iter882.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18164,10 +18164,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype879, _size876) = iprot.readListBegin() - for _i880 in xrange(_size876): - _elem881 = iprot.readString() - self.success.append(_elem881) + (_etype886, _size883) = iprot.readListBegin() + for _i887 in xrange(_size883): + _elem888 = iprot.readString() + self.success.append(_elem888) iprot.readListEnd() else: iprot.skip(ftype) @@ -18190,8 +18190,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter882 in self.success: - oprot.writeString(iter882) + for iter889 in self.success: + oprot.writeString(iter889) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18427,10 +18427,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype886, _size883) = iprot.readListBegin() - for _i887 in xrange(_size883): - _elem888 = iprot.readString() - self.tbl_names.append(_elem888) + (_etype893, _size890) = iprot.readListBegin() + for _i894 in xrange(_size890): + _elem895 = iprot.readString() + self.tbl_names.append(_elem895) iprot.readListEnd() else: iprot.skip(ftype) @@ -18451,8 +18451,8 @@ def write(self, oprot): if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter889 in self.tbl_names: - oprot.writeString(iter889) + for iter896 in self.tbl_names: + oprot.writeString(iter896) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18504,11 +18504,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype893, _size890) = iprot.readListBegin() - for _i894 in xrange(_size890): - _elem895 = Table() - _elem895.read(iprot) - self.success.append(_elem895) + (_etype900, _size897) = iprot.readListBegin() + for _i901 in xrange(_size897): + _elem902 = Table() + _elem902.read(iprot) + self.success.append(_elem902) iprot.readListEnd() else: iprot.skip(ftype) @@ -18525,8 +18525,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter896 in self.success: - iter896.write(oprot) + for iter903 in self.success: + iter903.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18918,10 +18918,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype900, _size897) = iprot.readListBegin() - for _i901 in xrange(_size897): - _elem902 = iprot.readString() - self.tbl_names.append(_elem902) + (_etype907, _size904) = iprot.readListBegin() + for _i908 in xrange(_size904): + _elem909 = iprot.readString() + self.tbl_names.append(_elem909) iprot.readListEnd() else: iprot.skip(ftype) @@ -18942,8 +18942,8 @@ def write(self, oprot): if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter903 in self.tbl_names: - oprot.writeString(iter903) + for iter910 in self.tbl_names: + oprot.writeString(iter910) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -19004,12 +19004,12 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype905, _vtype906, _size904 ) = iprot.readMapBegin() - for _i908 in xrange(_size904): - _key909 = iprot.readString() - _val910 = Materialization() - _val910.read(iprot) - self.success[_key909] = _val910 + (_ktype912, _vtype913, _size911 ) = iprot.readMapBegin() + for _i915 in xrange(_size911): + _key916 = iprot.readString() + _val917 = Materialization() + _val917.read(iprot) + self.success[_key916] = _val917 iprot.readMapEnd() else: iprot.skip(ftype) @@ -19044,9 +19044,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success)) - for kiter911,viter912 in self.success.items(): - oprot.writeString(kiter911) - viter912.write(oprot) + for kiter918,viter919 in self.success.items(): + oprot.writeString(kiter918) + viter919.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19398,10 +19398,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype916, _size913) = iprot.readListBegin() - for _i917 in xrange(_size913): - _elem918 = iprot.readString() - self.success.append(_elem918) + (_etype923, _size920) = iprot.readListBegin() + for _i924 in xrange(_size920): + _elem925 = iprot.readString() + self.success.append(_elem925) iprot.readListEnd() else: iprot.skip(ftype) @@ -19436,8 +19436,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter919 in self.success: - oprot.writeString(iter919) + for iter926 in self.success: + oprot.writeString(iter926) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20407,11 +20407,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype923, _size920) = iprot.readListBegin() - for _i924 in xrange(_size920): - _elem925 = Partition() - _elem925.read(iprot) - self.new_parts.append(_elem925) + (_etype930, _size927) = iprot.readListBegin() + for _i931 in xrange(_size927): + _elem932 = Partition() + _elem932.read(iprot) + self.new_parts.append(_elem932) iprot.readListEnd() else: iprot.skip(ftype) @@ -20428,8 +20428,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter926 in self.new_parts: - iter926.write(oprot) + for iter933 in self.new_parts: + iter933.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20587,11 +20587,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype930, _size927) = iprot.readListBegin() - for _i931 in xrange(_size927): - _elem932 = PartitionSpec() - _elem932.read(iprot) - self.new_parts.append(_elem932) + (_etype937, _size934) = iprot.readListBegin() + for _i938 in xrange(_size934): + _elem939 = PartitionSpec() + _elem939.read(iprot) + self.new_parts.append(_elem939) iprot.readListEnd() else: iprot.skip(ftype) @@ -20608,8 +20608,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter933 in self.new_parts: - iter933.write(oprot) + for iter940 in self.new_parts: + iter940.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20783,10 +20783,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype937, _size934) = iprot.readListBegin() - for _i938 in xrange(_size934): - _elem939 = iprot.readString() - self.part_vals.append(_elem939) + (_etype944, _size941) = iprot.readListBegin() + for _i945 in xrange(_size941): + _elem946 = iprot.readString() + self.part_vals.append(_elem946) iprot.readListEnd() else: iprot.skip(ftype) @@ -20811,8 +20811,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter940 in self.part_vals: - oprot.writeString(iter940) + for iter947 in self.part_vals: + oprot.writeString(iter947) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -21165,10 +21165,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype944, _size941) = iprot.readListBegin() - for _i945 in xrange(_size941): - _elem946 = iprot.readString() - self.part_vals.append(_elem946) + (_etype951, _size948) = iprot.readListBegin() + for _i952 in xrange(_size948): + _elem953 = iprot.readString() + self.part_vals.append(_elem953) iprot.readListEnd() else: iprot.skip(ftype) @@ -21199,8 +21199,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter947 in self.part_vals: - oprot.writeString(iter947) + for iter954 in self.part_vals: + oprot.writeString(iter954) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -21795,10 +21795,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype951, _size948) = iprot.readListBegin() - for _i952 in xrange(_size948): - _elem953 = iprot.readString() - self.part_vals.append(_elem953) + (_etype958, _size955) = iprot.readListBegin() + for _i959 in xrange(_size955): + _elem960 = iprot.readString() + self.part_vals.append(_elem960) iprot.readListEnd() else: iprot.skip(ftype) @@ -21828,8 +21828,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter954 in self.part_vals: - oprot.writeString(iter954) + for iter961 in self.part_vals: + oprot.writeString(iter961) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -22002,10 +22002,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype958, _size955) = iprot.readListBegin() - for _i959 in xrange(_size955): - _elem960 = iprot.readString() - self.part_vals.append(_elem960) + (_etype965, _size962) = iprot.readListBegin() + for _i966 in xrange(_size962): + _elem967 = iprot.readString() + self.part_vals.append(_elem967) iprot.readListEnd() else: iprot.skip(ftype) @@ -22041,8 +22041,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter961 in self.part_vals: - oprot.writeString(iter961) + for iter968 in self.part_vals: + oprot.writeString(iter968) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -22779,10 +22779,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype965, _size962) = iprot.readListBegin() - for _i966 in xrange(_size962): - _elem967 = iprot.readString() - self.part_vals.append(_elem967) + (_etype972, _size969) = iprot.readListBegin() + for _i973 in xrange(_size969): + _elem974 = iprot.readString() + self.part_vals.append(_elem974) iprot.readListEnd() else: iprot.skip(ftype) @@ -22807,8 +22807,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter968 in self.part_vals: - oprot.writeString(iter968) + for iter975 in self.part_vals: + oprot.writeString(iter975) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -22967,11 +22967,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype970, _vtype971, _size969 ) = iprot.readMapBegin() - for _i973 in xrange(_size969): - _key974 = iprot.readString() - _val975 = iprot.readString() - self.partitionSpecs[_key974] = _val975 + (_ktype977, _vtype978, _size976 ) = iprot.readMapBegin() + for _i980 in xrange(_size976): + _key981 = iprot.readString() + _val982 = iprot.readString() + self.partitionSpecs[_key981] = _val982 iprot.readMapEnd() else: iprot.skip(ftype) @@ -23008,9 +23008,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter976,viter977 in self.partitionSpecs.items(): - oprot.writeString(kiter976) - oprot.writeString(viter977) + for kiter983,viter984 in self.partitionSpecs.items(): + oprot.writeString(kiter983) + oprot.writeString(viter984) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -23215,11 +23215,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype979, _vtype980, _size978 ) = iprot.readMapBegin() - for _i982 in xrange(_size978): - _key983 = iprot.readString() - _val984 = iprot.readString() - self.partitionSpecs[_key983] = _val984 + (_ktype986, _vtype987, _size985 ) = iprot.readMapBegin() + for _i989 in xrange(_size985): + _key990 = iprot.readString() + _val991 = iprot.readString() + self.partitionSpecs[_key990] = _val991 iprot.readMapEnd() else: iprot.skip(ftype) @@ -23256,9 +23256,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter985,viter986 in self.partitionSpecs.items(): - oprot.writeString(kiter985) - oprot.writeString(viter986) + for kiter992,viter993 in self.partitionSpecs.items(): + oprot.writeString(kiter992) + oprot.writeString(viter993) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -23341,11 +23341,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype990, _size987) = iprot.readListBegin() - for _i991 in xrange(_size987): - _elem992 = Partition() - _elem992.read(iprot) - self.success.append(_elem992) + (_etype997, _size994) = iprot.readListBegin() + for _i998 in xrange(_size994): + _elem999 = Partition() + _elem999.read(iprot) + self.success.append(_elem999) iprot.readListEnd() else: iprot.skip(ftype) @@ -23386,8 +23386,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter993 in self.success: - iter993.write(oprot) + for iter1000 in self.success: + iter1000.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23481,10 +23481,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype997, _size994) = iprot.readListBegin() - for _i998 in xrange(_size994): - _elem999 = iprot.readString() - self.part_vals.append(_elem999) + (_etype1004, _size1001) = iprot.readListBegin() + for _i1005 in xrange(_size1001): + _elem1006 = iprot.readString() + self.part_vals.append(_elem1006) iprot.readListEnd() else: iprot.skip(ftype) @@ -23496,10 +23496,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype1003, _size1000) = iprot.readListBegin() - for _i1004 in xrange(_size1000): - _elem1005 = iprot.readString() - self.group_names.append(_elem1005) + (_etype1010, _size1007) = iprot.readListBegin() + for _i1011 in xrange(_size1007): + _elem1012 = iprot.readString() + self.group_names.append(_elem1012) iprot.readListEnd() else: iprot.skip(ftype) @@ -23524,8 +23524,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1006 in self.part_vals: - oprot.writeString(iter1006) + for iter1013 in self.part_vals: + oprot.writeString(iter1013) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -23535,8 +23535,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1007 in self.group_names: - oprot.writeString(iter1007) + for iter1014 in self.group_names: + oprot.writeString(iter1014) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -23965,11 +23965,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1011, _size1008) = iprot.readListBegin() - for _i1012 in xrange(_size1008): - _elem1013 = Partition() - _elem1013.read(iprot) - self.success.append(_elem1013) + (_etype1018, _size1015) = iprot.readListBegin() + for _i1019 in xrange(_size1015): + _elem1020 = Partition() + _elem1020.read(iprot) + self.success.append(_elem1020) iprot.readListEnd() else: iprot.skip(ftype) @@ -23998,8 +23998,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1014 in self.success: - iter1014.write(oprot) + for iter1021 in self.success: + iter1021.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24093,10 +24093,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype1018, _size1015) = iprot.readListBegin() - for _i1019 in xrange(_size1015): - _elem1020 = iprot.readString() - self.group_names.append(_elem1020) + (_etype1025, _size1022) = iprot.readListBegin() + for _i1026 in xrange(_size1022): + _elem1027 = iprot.readString() + self.group_names.append(_elem1027) iprot.readListEnd() else: iprot.skip(ftype) @@ -24129,8 +24129,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1021 in self.group_names: - oprot.writeString(iter1021) + for iter1028 in self.group_names: + oprot.writeString(iter1028) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -24191,11 +24191,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1025, _size1022) = iprot.readListBegin() - for _i1026 in xrange(_size1022): - _elem1027 = Partition() - _elem1027.read(iprot) - self.success.append(_elem1027) + (_etype1032, _size1029) = iprot.readListBegin() + for _i1033 in xrange(_size1029): + _elem1034 = Partition() + _elem1034.read(iprot) + self.success.append(_elem1034) iprot.readListEnd() else: iprot.skip(ftype) @@ -24224,8 +24224,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1028 in self.success: - iter1028.write(oprot) + for iter1035 in self.success: + iter1035.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24383,11 +24383,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1032, _size1029) = iprot.readListBegin() - for _i1033 in xrange(_size1029): - _elem1034 = PartitionSpec() - _elem1034.read(iprot) - self.success.append(_elem1034) + (_etype1039, _size1036) = iprot.readListBegin() + for _i1040 in xrange(_size1036): + _elem1041 = PartitionSpec() + _elem1041.read(iprot) + self.success.append(_elem1041) iprot.readListEnd() else: iprot.skip(ftype) @@ -24416,8 +24416,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1035 in self.success: - iter1035.write(oprot) + for iter1042 in self.success: + iter1042.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24575,10 +24575,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1039, _size1036) = iprot.readListBegin() - for _i1040 in xrange(_size1036): - _elem1041 = iprot.readString() - self.success.append(_elem1041) + (_etype1046, _size1043) = iprot.readListBegin() + for _i1047 in xrange(_size1043): + _elem1048 = iprot.readString() + self.success.append(_elem1048) iprot.readListEnd() else: iprot.skip(ftype) @@ -24607,8 +24607,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1042 in self.success: - oprot.writeString(iter1042) + for iter1049 in self.success: + oprot.writeString(iter1049) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24848,10 +24848,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1046, _size1043) = iprot.readListBegin() - for _i1047 in xrange(_size1043): - _elem1048 = iprot.readString() - self.part_vals.append(_elem1048) + (_etype1053, _size1050) = iprot.readListBegin() + for _i1054 in xrange(_size1050): + _elem1055 = iprot.readString() + self.part_vals.append(_elem1055) iprot.readListEnd() else: iprot.skip(ftype) @@ -24881,8 +24881,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1049 in self.part_vals: - oprot.writeString(iter1049) + for iter1056 in self.part_vals: + oprot.writeString(iter1056) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -24946,11 +24946,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1053, _size1050) = iprot.readListBegin() - for _i1054 in xrange(_size1050): - _elem1055 = Partition() - _elem1055.read(iprot) - self.success.append(_elem1055) + (_etype1060, _size1057) = iprot.readListBegin() + for _i1061 in xrange(_size1057): + _elem1062 = Partition() + _elem1062.read(iprot) + self.success.append(_elem1062) iprot.readListEnd() else: iprot.skip(ftype) @@ -24979,8 +24979,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1056 in self.success: - iter1056.write(oprot) + for iter1063 in self.success: + iter1063.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25067,10 +25067,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1060, _size1057) = iprot.readListBegin() - for _i1061 in xrange(_size1057): - _elem1062 = iprot.readString() - self.part_vals.append(_elem1062) + (_etype1067, _size1064) = iprot.readListBegin() + for _i1068 in xrange(_size1064): + _elem1069 = iprot.readString() + self.part_vals.append(_elem1069) iprot.readListEnd() else: iprot.skip(ftype) @@ -25087,10 +25087,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype1066, _size1063) = iprot.readListBegin() - for _i1067 in xrange(_size1063): - _elem1068 = iprot.readString() - self.group_names.append(_elem1068) + (_etype1073, _size1070) = iprot.readListBegin() + for _i1074 in xrange(_size1070): + _elem1075 = iprot.readString() + self.group_names.append(_elem1075) iprot.readListEnd() else: iprot.skip(ftype) @@ -25115,8 +25115,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1069 in self.part_vals: - oprot.writeString(iter1069) + for iter1076 in self.part_vals: + oprot.writeString(iter1076) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -25130,8 +25130,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1070 in self.group_names: - oprot.writeString(iter1070) + for iter1077 in self.group_names: + oprot.writeString(iter1077) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -25193,11 +25193,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1074, _size1071) = iprot.readListBegin() - for _i1075 in xrange(_size1071): - _elem1076 = Partition() - _elem1076.read(iprot) - self.success.append(_elem1076) + (_etype1081, _size1078) = iprot.readListBegin() + for _i1082 in xrange(_size1078): + _elem1083 = Partition() + _elem1083.read(iprot) + self.success.append(_elem1083) iprot.readListEnd() else: iprot.skip(ftype) @@ -25226,8 +25226,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1077 in self.success: - iter1077.write(oprot) + for iter1084 in self.success: + iter1084.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25308,10 +25308,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1081, _size1078) = iprot.readListBegin() - for _i1082 in xrange(_size1078): - _elem1083 = iprot.readString() - self.part_vals.append(_elem1083) + (_etype1088, _size1085) = iprot.readListBegin() + for _i1089 in xrange(_size1085): + _elem1090 = iprot.readString() + self.part_vals.append(_elem1090) iprot.readListEnd() else: iprot.skip(ftype) @@ -25341,8 +25341,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1084 in self.part_vals: - oprot.writeString(iter1084) + for iter1091 in self.part_vals: + oprot.writeString(iter1091) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -25406,10 +25406,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1088, _size1085) = iprot.readListBegin() - for _i1089 in xrange(_size1085): - _elem1090 = iprot.readString() - self.success.append(_elem1090) + (_etype1095, _size1092) = iprot.readListBegin() + for _i1096 in xrange(_size1092): + _elem1097 = iprot.readString() + self.success.append(_elem1097) iprot.readListEnd() else: iprot.skip(ftype) @@ -25438,8 +25438,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1091 in self.success: - oprot.writeString(iter1091) + for iter1098 in self.success: + oprot.writeString(iter1098) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25610,11 +25610,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1095, _size1092) = iprot.readListBegin() - for _i1096 in xrange(_size1092): - _elem1097 = Partition() - _elem1097.read(iprot) - self.success.append(_elem1097) + (_etype1102, _size1099) = iprot.readListBegin() + for _i1103 in xrange(_size1099): + _elem1104 = Partition() + _elem1104.read(iprot) + self.success.append(_elem1104) iprot.readListEnd() else: iprot.skip(ftype) @@ -25643,8 +25643,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1098 in self.success: - iter1098.write(oprot) + for iter1105 in self.success: + iter1105.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25815,11 +25815,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1102, _size1099) = iprot.readListBegin() - for _i1103 in xrange(_size1099): - _elem1104 = PartitionSpec() - _elem1104.read(iprot) - self.success.append(_elem1104) + (_etype1109, _size1106) = iprot.readListBegin() + for _i1110 in xrange(_size1106): + _elem1111 = PartitionSpec() + _elem1111.read(iprot) + self.success.append(_elem1111) iprot.readListEnd() else: iprot.skip(ftype) @@ -25848,8 +25848,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1105 in self.success: - iter1105.write(oprot) + for iter1112 in self.success: + iter1112.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26269,10 +26269,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype1109, _size1106) = iprot.readListBegin() - for _i1110 in xrange(_size1106): - _elem1111 = iprot.readString() - self.names.append(_elem1111) + (_etype1116, _size1113) = iprot.readListBegin() + for _i1117 in xrange(_size1113): + _elem1118 = iprot.readString() + self.names.append(_elem1118) iprot.readListEnd() else: iprot.skip(ftype) @@ -26297,8 +26297,8 @@ def write(self, oprot): if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter1112 in self.names: - oprot.writeString(iter1112) + for iter1119 in self.names: + oprot.writeString(iter1119) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -26357,11 +26357,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1116, _size1113) = iprot.readListBegin() - for _i1117 in xrange(_size1113): - _elem1118 = Partition() - _elem1118.read(iprot) - self.success.append(_elem1118) + (_etype1123, _size1120) = iprot.readListBegin() + for _i1124 in xrange(_size1120): + _elem1125 = Partition() + _elem1125.read(iprot) + self.success.append(_elem1125) iprot.readListEnd() else: iprot.skip(ftype) @@ -26390,8 +26390,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1119 in self.success: - iter1119.write(oprot) + for iter1126 in self.success: + iter1126.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26641,11 +26641,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1123, _size1120) = iprot.readListBegin() - for _i1124 in xrange(_size1120): - _elem1125 = Partition() - _elem1125.read(iprot) - self.new_parts.append(_elem1125) + (_etype1130, _size1127) = iprot.readListBegin() + for _i1131 in xrange(_size1127): + _elem1132 = Partition() + _elem1132.read(iprot) + self.new_parts.append(_elem1132) iprot.readListEnd() else: iprot.skip(ftype) @@ -26670,8 +26670,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter1126 in self.new_parts: - iter1126.write(oprot) + for iter1133 in self.new_parts: + iter1133.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -26824,11 +26824,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1130, _size1127) = iprot.readListBegin() - for _i1131 in xrange(_size1127): - _elem1132 = Partition() - _elem1132.read(iprot) - self.new_parts.append(_elem1132) + (_etype1137, _size1134) = iprot.readListBegin() + for _i1138 in xrange(_size1134): + _elem1139 = Partition() + _elem1139.read(iprot) + self.new_parts.append(_elem1139) iprot.readListEnd() else: iprot.skip(ftype) @@ -26859,8 +26859,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter1133 in self.new_parts: - iter1133.write(oprot) + for iter1140 in self.new_parts: + iter1140.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -27204,10 +27204,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1137, _size1134) = iprot.readListBegin() - for _i1138 in xrange(_size1134): - _elem1139 = iprot.readString() - self.part_vals.append(_elem1139) + (_etype1144, _size1141) = iprot.readListBegin() + for _i1145 in xrange(_size1141): + _elem1146 = iprot.readString() + self.part_vals.append(_elem1146) iprot.readListEnd() else: iprot.skip(ftype) @@ -27238,8 +27238,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1140 in self.part_vals: - oprot.writeString(iter1140) + for iter1147 in self.part_vals: + oprot.writeString(iter1147) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -27381,10 +27381,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype1144, _size1141) = iprot.readListBegin() - for _i1145 in xrange(_size1141): - _elem1146 = iprot.readString() - self.part_vals.append(_elem1146) + (_etype1151, _size1148) = iprot.readListBegin() + for _i1152 in xrange(_size1148): + _elem1153 = iprot.readString() + self.part_vals.append(_elem1153) iprot.readListEnd() else: iprot.skip(ftype) @@ -27406,8 +27406,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1147 in self.part_vals: - oprot.writeString(iter1147) + for iter1154 in self.part_vals: + oprot.writeString(iter1154) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -27765,10 +27765,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1151, _size1148) = iprot.readListBegin() - for _i1152 in xrange(_size1148): - _elem1153 = iprot.readString() - self.success.append(_elem1153) + (_etype1158, _size1155) = iprot.readListBegin() + for _i1159 in xrange(_size1155): + _elem1160 = iprot.readString() + self.success.append(_elem1160) iprot.readListEnd() else: iprot.skip(ftype) @@ -27791,8 +27791,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1154 in self.success: - oprot.writeString(iter1154) + for iter1161 in self.success: + oprot.writeString(iter1161) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -27916,11 +27916,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype1156, _vtype1157, _size1155 ) = iprot.readMapBegin() - for _i1159 in xrange(_size1155): - _key1160 = iprot.readString() - _val1161 = iprot.readString() - self.success[_key1160] = _val1161 + (_ktype1163, _vtype1164, _size1162 ) = iprot.readMapBegin() + for _i1166 in xrange(_size1162): + _key1167 = iprot.readString() + _val1168 = iprot.readString() + self.success[_key1167] = _val1168 iprot.readMapEnd() else: iprot.skip(ftype) @@ -27943,9 +27943,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) - for kiter1162,viter1163 in self.success.items(): - oprot.writeString(kiter1162) - oprot.writeString(viter1163) + for kiter1169,viter1170 in self.success.items(): + oprot.writeString(kiter1169) + oprot.writeString(viter1170) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -28021,11 +28021,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1165, _vtype1166, _size1164 ) = iprot.readMapBegin() - for _i1168 in xrange(_size1164): - _key1169 = iprot.readString() - _val1170 = iprot.readString() - self.part_vals[_key1169] = _val1170 + (_ktype1172, _vtype1173, _size1171 ) = iprot.readMapBegin() + for _i1175 in xrange(_size1171): + _key1176 = iprot.readString() + _val1177 = iprot.readString() + self.part_vals[_key1176] = _val1177 iprot.readMapEnd() else: iprot.skip(ftype) @@ -28055,9 +28055,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter1171,viter1172 in self.part_vals.items(): - oprot.writeString(kiter1171) - oprot.writeString(viter1172) + for kiter1178,viter1179 in self.part_vals.items(): + oprot.writeString(kiter1178) + oprot.writeString(viter1179) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -28271,11 +28271,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1174, _vtype1175, _size1173 ) = iprot.readMapBegin() - for _i1177 in xrange(_size1173): - _key1178 = iprot.readString() - _val1179 = iprot.readString() - self.part_vals[_key1178] = _val1179 + (_ktype1181, _vtype1182, _size1180 ) = iprot.readMapBegin() + for _i1184 in xrange(_size1180): + _key1185 = iprot.readString() + _val1186 = iprot.readString() + self.part_vals[_key1185] = _val1186 iprot.readMapEnd() else: iprot.skip(ftype) @@ -28305,9 +28305,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter1180,viter1181 in self.part_vals.items(): - oprot.writeString(kiter1180) - oprot.writeString(viter1181) + for kiter1187,viter1188 in self.part_vals.items(): + oprot.writeString(kiter1187) + oprot.writeString(viter1188) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -29362,11 +29362,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1185, _size1182) = iprot.readListBegin() - for _i1186 in xrange(_size1182): - _elem1187 = Index() - _elem1187.read(iprot) - self.success.append(_elem1187) + (_etype1192, _size1189) = iprot.readListBegin() + for _i1193 in xrange(_size1189): + _elem1194 = Index() + _elem1194.read(iprot) + self.success.append(_elem1194) iprot.readListEnd() else: iprot.skip(ftype) @@ -29395,8 +29395,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1188 in self.success: - iter1188.write(oprot) + for iter1195 in self.success: + iter1195.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29551,10 +29551,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1192, _size1189) = iprot.readListBegin() - for _i1193 in xrange(_size1189): - _elem1194 = iprot.readString() - self.success.append(_elem1194) + (_etype1199, _size1196) = iprot.readListBegin() + for _i1200 in xrange(_size1196): + _elem1201 = iprot.readString() + self.success.append(_elem1201) iprot.readListEnd() else: iprot.skip(ftype) @@ -29577,8 +29577,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1195 in self.success: - oprot.writeString(iter1195) + for iter1202 in self.success: + oprot.writeString(iter1202) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -32762,10 +32762,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1199, _size1196) = iprot.readListBegin() - for _i1200 in xrange(_size1196): - _elem1201 = iprot.readString() - self.success.append(_elem1201) + (_etype1206, _size1203) = iprot.readListBegin() + for _i1207 in xrange(_size1203): + _elem1208 = iprot.readString() + self.success.append(_elem1208) iprot.readListEnd() else: iprot.skip(ftype) @@ -32788,8 +32788,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1202 in self.success: - oprot.writeString(iter1202) + for iter1209 in self.success: + oprot.writeString(iter1209) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -33477,10 +33477,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1206, _size1203) = iprot.readListBegin() - for _i1207 in xrange(_size1203): - _elem1208 = iprot.readString() - self.success.append(_elem1208) + (_etype1213, _size1210) = iprot.readListBegin() + for _i1214 in xrange(_size1210): + _elem1215 = iprot.readString() + self.success.append(_elem1215) iprot.readListEnd() else: iprot.skip(ftype) @@ -33503,8 +33503,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1209 in self.success: - oprot.writeString(iter1209) + for iter1216 in self.success: + oprot.writeString(iter1216) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -34018,11 +34018,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1213, _size1210) = iprot.readListBegin() - for _i1214 in xrange(_size1210): - _elem1215 = Role() - _elem1215.read(iprot) - self.success.append(_elem1215) + (_etype1220, _size1217) = iprot.readListBegin() + for _i1221 in xrange(_size1217): + _elem1222 = Role() + _elem1222.read(iprot) + self.success.append(_elem1222) iprot.readListEnd() else: iprot.skip(ftype) @@ -34045,8 +34045,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1216 in self.success: - iter1216.write(oprot) + for iter1223 in self.success: + iter1223.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -34555,10 +34555,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype1220, _size1217) = iprot.readListBegin() - for _i1221 in xrange(_size1217): - _elem1222 = iprot.readString() - self.group_names.append(_elem1222) + (_etype1227, _size1224) = iprot.readListBegin() + for _i1228 in xrange(_size1224): + _elem1229 = iprot.readString() + self.group_names.append(_elem1229) iprot.readListEnd() else: iprot.skip(ftype) @@ -34583,8 +34583,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1223 in self.group_names: - oprot.writeString(iter1223) + for iter1230 in self.group_names: + oprot.writeString(iter1230) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -34811,11 +34811,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1227, _size1224) = iprot.readListBegin() - for _i1228 in xrange(_size1224): - _elem1229 = HiveObjectPrivilege() - _elem1229.read(iprot) - self.success.append(_elem1229) + (_etype1234, _size1231) = iprot.readListBegin() + for _i1235 in xrange(_size1231): + _elem1236 = HiveObjectPrivilege() + _elem1236.read(iprot) + self.success.append(_elem1236) iprot.readListEnd() else: iprot.skip(ftype) @@ -34838,8 +34838,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1230 in self.success: - iter1230.write(oprot) + for iter1237 in self.success: + iter1237.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -35337,10 +35337,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype1234, _size1231) = iprot.readListBegin() - for _i1235 in xrange(_size1231): - _elem1236 = iprot.readString() - self.group_names.append(_elem1236) + (_etype1241, _size1238) = iprot.readListBegin() + for _i1242 in xrange(_size1238): + _elem1243 = iprot.readString() + self.group_names.append(_elem1243) iprot.readListEnd() else: iprot.skip(ftype) @@ -35361,8 +35361,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1237 in self.group_names: - oprot.writeString(iter1237) + for iter1244 in self.group_names: + oprot.writeString(iter1244) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -35417,10 +35417,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1241, _size1238) = iprot.readListBegin() - for _i1242 in xrange(_size1238): - _elem1243 = iprot.readString() - self.success.append(_elem1243) + (_etype1248, _size1245) = iprot.readListBegin() + for _i1249 in xrange(_size1245): + _elem1250 = iprot.readString() + self.success.append(_elem1250) iprot.readListEnd() else: iprot.skip(ftype) @@ -35443,8 +35443,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1244 in self.success: - oprot.writeString(iter1244) + for iter1251 in self.success: + oprot.writeString(iter1251) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36376,10 +36376,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1248, _size1245) = iprot.readListBegin() - for _i1249 in xrange(_size1245): - _elem1250 = iprot.readString() - self.success.append(_elem1250) + (_etype1255, _size1252) = iprot.readListBegin() + for _i1256 in xrange(_size1252): + _elem1257 = iprot.readString() + self.success.append(_elem1257) iprot.readListEnd() else: iprot.skip(ftype) @@ -36396,8 +36396,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1251 in self.success: - oprot.writeString(iter1251) + for iter1258 in self.success: + oprot.writeString(iter1258) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -36924,10 +36924,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1255, _size1252) = iprot.readListBegin() - for _i1256 in xrange(_size1252): - _elem1257 = iprot.readString() - self.success.append(_elem1257) + (_etype1262, _size1259) = iprot.readListBegin() + for _i1263 in xrange(_size1259): + _elem1264 = iprot.readString() + self.success.append(_elem1264) iprot.readListEnd() else: iprot.skip(ftype) @@ -36944,8 +36944,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1258 in self.success: - oprot.writeString(iter1258) + for iter1265 in self.success: + oprot.writeString(iter1265) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index 0c60aff5aa..1a68cccb20 100644 --- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -9580,6 +9580,8 @@ class OpenTxnRequest: - user - hostname - agentInfo + - replPolicy + - replSrcTxnId """ thrift_spec = ( @@ -9588,13 +9590,17 @@ class OpenTxnRequest: (2, TType.STRING, 'user', None, None, ), # 2 (3, TType.STRING, 'hostname', None, None, ), # 3 (4, TType.STRING, 'agentInfo', None, "Unknown", ), # 4 + (5, TType.STRING, 'replPolicy', None, None, ), # 5 + (6, TType.LIST, 'replSrcTxnId', (TType.I64,None), None, ), # 6 ) - def __init__(self, num_txns=None, user=None, hostname=None, agentInfo=thrift_spec[4][4],): + def __init__(self, num_txns=None, user=None, hostname=None, agentInfo=thrift_spec[4][4], replPolicy=None, replSrcTxnId=None,): self.num_txns = num_txns self.user = user self.hostname = hostname self.agentInfo = agentInfo + self.replPolicy = replPolicy + self.replSrcTxnId = replSrcTxnId 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: @@ -9625,6 +9631,21 @@ def read(self, iprot): self.agentInfo = iprot.readString() else: iprot.skip(ftype) + elif fid == 5: + if ftype == TType.STRING: + self.replPolicy = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 6: + if ftype == TType.LIST: + self.replSrcTxnId = [] + (_etype479, _size476) = iprot.readListBegin() + for _i480 in xrange(_size476): + _elem481 = iprot.readI64() + self.replSrcTxnId.append(_elem481) + iprot.readListEnd() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -9651,6 +9672,17 @@ def write(self, oprot): oprot.writeFieldBegin('agentInfo', TType.STRING, 4) oprot.writeString(self.agentInfo) oprot.writeFieldEnd() + if self.replPolicy is not None: + oprot.writeFieldBegin('replPolicy', TType.STRING, 5) + oprot.writeString(self.replPolicy) + oprot.writeFieldEnd() + if self.replSrcTxnId is not None: + oprot.writeFieldBegin('replSrcTxnId', TType.LIST, 6) + oprot.writeListBegin(TType.I64, len(self.replSrcTxnId)) + for iter482 in self.replSrcTxnId: + oprot.writeI64(iter482) + oprot.writeListEnd() + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -9670,6 +9702,8 @@ def __hash__(self): value = (value * 31) ^ hash(self.user) value = (value * 31) ^ hash(self.hostname) value = (value * 31) ^ hash(self.agentInfo) + value = (value * 31) ^ hash(self.replPolicy) + value = (value * 31) ^ hash(self.replSrcTxnId) return value def __repr__(self): @@ -9709,10 +9743,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.txn_ids = [] - (_etype479, _size476) = iprot.readListBegin() - for _i480 in xrange(_size476): - _elem481 = iprot.readI64() - self.txn_ids.append(_elem481) + (_etype486, _size483) = iprot.readListBegin() + for _i487 in xrange(_size483): + _elem488 = iprot.readI64() + self.txn_ids.append(_elem488) iprot.readListEnd() else: iprot.skip(ftype) @@ -9729,8 +9763,8 @@ def write(self, oprot): if self.txn_ids is not None: oprot.writeFieldBegin('txn_ids', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.txn_ids)) - for iter482 in self.txn_ids: - oprot.writeI64(iter482) + for iter489 in self.txn_ids: + oprot.writeI64(iter489) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -9762,15 +9796,18 @@ class AbortTxnRequest: """ Attributes: - txnid + - replPolicy """ thrift_spec = ( None, # 0 (1, TType.I64, 'txnid', None, None, ), # 1 + (2, TType.STRING, 'replPolicy', None, None, ), # 2 ) - def __init__(self, txnid=None,): + def __init__(self, txnid=None, replPolicy=None,): self.txnid = txnid + self.replPolicy = replPolicy 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: @@ -9786,6 +9823,11 @@ def read(self, iprot): self.txnid = iprot.readI64() else: iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.replPolicy = iprot.readString() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -9800,6 +9842,10 @@ def write(self, oprot): oprot.writeFieldBegin('txnid', TType.I64, 1) oprot.writeI64(self.txnid) oprot.writeFieldEnd() + if self.replPolicy is not None: + oprot.writeFieldBegin('replPolicy', TType.STRING, 2) + oprot.writeString(self.replPolicy) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -9812,6 +9858,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.txnid) + value = (value * 31) ^ hash(self.replPolicy) return value def __repr__(self): @@ -9851,10 +9898,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.txn_ids = [] - (_etype486, _size483) = iprot.readListBegin() - for _i487 in xrange(_size483): - _elem488 = iprot.readI64() - self.txn_ids.append(_elem488) + (_etype493, _size490) = iprot.readListBegin() + for _i494 in xrange(_size490): + _elem495 = iprot.readI64() + self.txn_ids.append(_elem495) iprot.readListEnd() else: iprot.skip(ftype) @@ -9871,8 +9918,8 @@ def write(self, oprot): if self.txn_ids is not None: oprot.writeFieldBegin('txn_ids', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.txn_ids)) - for iter489 in self.txn_ids: - oprot.writeI64(iter489) + for iter496 in self.txn_ids: + oprot.writeI64(iter496) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -9904,15 +9951,18 @@ class CommitTxnRequest: """ Attributes: - txnid + - replPolicy """ thrift_spec = ( None, # 0 (1, TType.I64, 'txnid', None, None, ), # 1 + (2, TType.STRING, 'replPolicy', None, None, ), # 2 ) - def __init__(self, txnid=None,): + def __init__(self, txnid=None, replPolicy=None,): self.txnid = txnid + self.replPolicy = replPolicy 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: @@ -9928,6 +9978,11 @@ def read(self, iprot): self.txnid = iprot.readI64() else: iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.replPolicy = iprot.readString() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -9938,6 +9993,145 @@ def write(self, oprot): oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) return oprot.writeStructBegin('CommitTxnRequest') + if self.txnid is not None: + oprot.writeFieldBegin('txnid', TType.I64, 1) + oprot.writeI64(self.txnid) + oprot.writeFieldEnd() + if self.replPolicy is not None: + oprot.writeFieldBegin('replPolicy', TType.STRING, 2) + oprot.writeString(self.replPolicy) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.txnid is None: + raise TProtocol.TProtocolException(message='Required field txnid is unset!') + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.txnid) + value = (value * 31) ^ hash(self.replPolicy) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class GetTargetTxnIdRequest: + """ + Attributes: + - txnid + """ + + thrift_spec = ( + None, # 0 + (1, TType.I64, 'txnid', None, None, ), # 1 + ) + + def __init__(self, txnid=None,): + self.txnid = txnid + + 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: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.I64: + self.txnid = iprot.readI64() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('GetTargetTxnIdRequest') + if self.txnid is not None: + oprot.writeFieldBegin('txnid', TType.I64, 1) + oprot.writeI64(self.txnid) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.txnid is None: + raise TProtocol.TProtocolException(message='Required field txnid is unset!') + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.txnid) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class GetTargetTxnIdResponse: + """ + Attributes: + - txnid + """ + + thrift_spec = ( + None, # 0 + (1, TType.I64, 'txnid', None, None, ), # 1 + ) + + def __init__(self, txnid=None,): + self.txnid = txnid + + 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: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.I64: + self.txnid = iprot.readI64() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('GetTargetTxnIdResponse') if self.txnid is not None: oprot.writeFieldBegin('txnid', TType.I64, 1) oprot.writeI64(self.txnid) @@ -9996,10 +10190,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fullTableNames = [] - (_etype493, _size490) = iprot.readListBegin() - for _i494 in xrange(_size490): - _elem495 = iprot.readString() - self.fullTableNames.append(_elem495) + (_etype500, _size497) = iprot.readListBegin() + for _i501 in xrange(_size497): + _elem502 = iprot.readString() + self.fullTableNames.append(_elem502) iprot.readListEnd() else: iprot.skip(ftype) @@ -10021,8 +10215,8 @@ def write(self, oprot): if self.fullTableNames is not None: oprot.writeFieldBegin('fullTableNames', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.fullTableNames)) - for iter496 in self.fullTableNames: - oprot.writeString(iter496) + for iter503 in self.fullTableNames: + oprot.writeString(iter503) oprot.writeListEnd() oprot.writeFieldEnd() if self.validTxnList is not None: @@ -10105,10 +10299,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.invalidWriteIds = [] - (_etype500, _size497) = iprot.readListBegin() - for _i501 in xrange(_size497): - _elem502 = iprot.readI64() - self.invalidWriteIds.append(_elem502) + (_etype507, _size504) = iprot.readListBegin() + for _i508 in xrange(_size504): + _elem509 = iprot.readI64() + self.invalidWriteIds.append(_elem509) iprot.readListEnd() else: iprot.skip(ftype) @@ -10143,8 +10337,8 @@ def write(self, oprot): if self.invalidWriteIds is not None: oprot.writeFieldBegin('invalidWriteIds', TType.LIST, 3) oprot.writeListBegin(TType.I64, len(self.invalidWriteIds)) - for iter503 in self.invalidWriteIds: - oprot.writeI64(iter503) + for iter510 in self.invalidWriteIds: + oprot.writeI64(iter510) oprot.writeListEnd() oprot.writeFieldEnd() if self.minOpenWriteId is not None: @@ -10216,11 +10410,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.tblValidWriteIds = [] - (_etype507, _size504) = iprot.readListBegin() - for _i508 in xrange(_size504): - _elem509 = TableValidWriteIds() - _elem509.read(iprot) - self.tblValidWriteIds.append(_elem509) + (_etype514, _size511) = iprot.readListBegin() + for _i515 in xrange(_size511): + _elem516 = TableValidWriteIds() + _elem516.read(iprot) + self.tblValidWriteIds.append(_elem516) iprot.readListEnd() else: iprot.skip(ftype) @@ -10237,8 +10431,8 @@ def write(self, oprot): if self.tblValidWriteIds is not None: oprot.writeFieldBegin('tblValidWriteIds', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.tblValidWriteIds)) - for iter510 in self.tblValidWriteIds: - iter510.write(oprot) + for iter517 in self.tblValidWriteIds: + iter517.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -10298,10 +10492,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.txnIds = [] - (_etype514, _size511) = iprot.readListBegin() - for _i515 in xrange(_size511): - _elem516 = iprot.readI64() - self.txnIds.append(_elem516) + (_etype521, _size518) = iprot.readListBegin() + for _i522 in xrange(_size518): + _elem523 = iprot.readI64() + self.txnIds.append(_elem523) iprot.readListEnd() else: iprot.skip(ftype) @@ -10328,8 +10522,8 @@ def write(self, oprot): if self.txnIds is not None: oprot.writeFieldBegin('txnIds', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.txnIds)) - for iter517 in self.txnIds: - oprot.writeI64(iter517) + for iter524 in self.txnIds: + oprot.writeI64(iter524) oprot.writeListEnd() oprot.writeFieldEnd() if self.dbName is not None: @@ -10479,11 +10673,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.txnToWriteIds = [] - (_etype521, _size518) = iprot.readListBegin() - for _i522 in xrange(_size518): - _elem523 = TxnToWriteId() - _elem523.read(iprot) - self.txnToWriteIds.append(_elem523) + (_etype528, _size525) = iprot.readListBegin() + for _i529 in xrange(_size525): + _elem530 = TxnToWriteId() + _elem530.read(iprot) + self.txnToWriteIds.append(_elem530) iprot.readListEnd() else: iprot.skip(ftype) @@ -10500,8 +10694,8 @@ def write(self, oprot): if self.txnToWriteIds is not None: oprot.writeFieldBegin('txnToWriteIds', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.txnToWriteIds)) - for iter524 in self.txnToWriteIds: - iter524.write(oprot) + for iter531 in self.txnToWriteIds: + iter531.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -10729,11 +10923,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.component = [] - (_etype528, _size525) = iprot.readListBegin() - for _i529 in xrange(_size525): - _elem530 = LockComponent() - _elem530.read(iprot) - self.component.append(_elem530) + (_etype535, _size532) = iprot.readListBegin() + for _i536 in xrange(_size532): + _elem537 = LockComponent() + _elem537.read(iprot) + self.component.append(_elem537) iprot.readListEnd() else: iprot.skip(ftype) @@ -10770,8 +10964,8 @@ def write(self, oprot): if self.component is not None: oprot.writeFieldBegin('component', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.component)) - for iter531 in self.component: - iter531.write(oprot) + for iter538 in self.component: + iter538.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.txnid is not None: @@ -11469,11 +11663,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.locks = [] - (_etype535, _size532) = iprot.readListBegin() - for _i536 in xrange(_size532): - _elem537 = ShowLocksResponseElement() - _elem537.read(iprot) - self.locks.append(_elem537) + (_etype542, _size539) = iprot.readListBegin() + for _i543 in xrange(_size539): + _elem544 = ShowLocksResponseElement() + _elem544.read(iprot) + self.locks.append(_elem544) iprot.readListEnd() else: iprot.skip(ftype) @@ -11490,8 +11684,8 @@ def write(self, oprot): if self.locks is not None: oprot.writeFieldBegin('locks', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.locks)) - for iter538 in self.locks: - iter538.write(oprot) + for iter545 in self.locks: + iter545.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -11706,20 +11900,20 @@ def read(self, iprot): if fid == 1: if ftype == TType.SET: self.aborted = set() - (_etype542, _size539) = iprot.readSetBegin() - for _i543 in xrange(_size539): - _elem544 = iprot.readI64() - self.aborted.add(_elem544) + (_etype549, _size546) = iprot.readSetBegin() + for _i550 in xrange(_size546): + _elem551 = iprot.readI64() + self.aborted.add(_elem551) iprot.readSetEnd() else: iprot.skip(ftype) elif fid == 2: if ftype == TType.SET: self.nosuch = set() - (_etype548, _size545) = iprot.readSetBegin() - for _i549 in xrange(_size545): - _elem550 = iprot.readI64() - self.nosuch.add(_elem550) + (_etype555, _size552) = iprot.readSetBegin() + for _i556 in xrange(_size552): + _elem557 = iprot.readI64() + self.nosuch.add(_elem557) iprot.readSetEnd() else: iprot.skip(ftype) @@ -11736,15 +11930,15 @@ def write(self, oprot): if self.aborted is not None: oprot.writeFieldBegin('aborted', TType.SET, 1) oprot.writeSetBegin(TType.I64, len(self.aborted)) - for iter551 in self.aborted: - oprot.writeI64(iter551) + for iter558 in self.aborted: + oprot.writeI64(iter558) oprot.writeSetEnd() oprot.writeFieldEnd() if self.nosuch is not None: oprot.writeFieldBegin('nosuch', TType.SET, 2) oprot.writeSetBegin(TType.I64, len(self.nosuch)) - for iter552 in self.nosuch: - oprot.writeI64(iter552) + for iter559 in self.nosuch: + oprot.writeI64(iter559) oprot.writeSetEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -11841,11 +12035,11 @@ def read(self, iprot): elif fid == 6: if ftype == TType.MAP: self.properties = {} - (_ktype554, _vtype555, _size553 ) = iprot.readMapBegin() - for _i557 in xrange(_size553): - _key558 = iprot.readString() - _val559 = iprot.readString() - self.properties[_key558] = _val559 + (_ktype561, _vtype562, _size560 ) = iprot.readMapBegin() + for _i564 in xrange(_size560): + _key565 = iprot.readString() + _val566 = iprot.readString() + self.properties[_key565] = _val566 iprot.readMapEnd() else: iprot.skip(ftype) @@ -11882,9 +12076,9 @@ def write(self, oprot): if self.properties is not None: oprot.writeFieldBegin('properties', TType.MAP, 6) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties)) - for kiter560,viter561 in self.properties.items(): - oprot.writeString(kiter560) - oprot.writeString(viter561) + for kiter567,viter568 in self.properties.items(): + oprot.writeString(kiter567) + oprot.writeString(viter568) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -12319,11 +12513,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.compacts = [] - (_etype565, _size562) = iprot.readListBegin() - for _i566 in xrange(_size562): - _elem567 = ShowCompactResponseElement() - _elem567.read(iprot) - self.compacts.append(_elem567) + (_etype572, _size569) = iprot.readListBegin() + for _i573 in xrange(_size569): + _elem574 = ShowCompactResponseElement() + _elem574.read(iprot) + self.compacts.append(_elem574) iprot.readListEnd() else: iprot.skip(ftype) @@ -12340,8 +12534,8 @@ def write(self, oprot): if self.compacts is not None: oprot.writeFieldBegin('compacts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.compacts)) - for iter568 in self.compacts: - iter568.write(oprot) + for iter575 in self.compacts: + iter575.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -12430,10 +12624,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.partitionnames = [] - (_etype572, _size569) = iprot.readListBegin() - for _i573 in xrange(_size569): - _elem574 = iprot.readString() - self.partitionnames.append(_elem574) + (_etype579, _size576) = iprot.readListBegin() + for _i580 in xrange(_size576): + _elem581 = iprot.readString() + self.partitionnames.append(_elem581) iprot.readListEnd() else: iprot.skip(ftype) @@ -12471,8 +12665,8 @@ def write(self, oprot): if self.partitionnames is not None: oprot.writeFieldBegin('partitionnames', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.partitionnames)) - for iter575 in self.partitionnames: - oprot.writeString(iter575) + for iter582 in self.partitionnames: + oprot.writeString(iter582) oprot.writeListEnd() oprot.writeFieldEnd() if self.operationType is not None: @@ -12694,10 +12888,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.SET: self.tablesUsed = set() - (_etype579, _size576) = iprot.readSetBegin() - for _i580 in xrange(_size576): - _elem581 = iprot.readString() - self.tablesUsed.add(_elem581) + (_etype586, _size583) = iprot.readSetBegin() + for _i587 in xrange(_size583): + _elem588 = iprot.readString() + self.tablesUsed.add(_elem588) iprot.readSetEnd() else: iprot.skip(ftype) @@ -12727,8 +12921,8 @@ def write(self, oprot): if self.tablesUsed is not None: oprot.writeFieldBegin('tablesUsed', TType.SET, 3) oprot.writeSetBegin(TType.STRING, len(self.tablesUsed)) - for iter582 in self.tablesUsed: - oprot.writeString(iter582) + for iter589 in self.tablesUsed: + oprot.writeString(iter589) oprot.writeSetEnd() oprot.writeFieldEnd() if self.validTxnList is not None: @@ -13024,11 +13218,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.events = [] - (_etype586, _size583) = iprot.readListBegin() - for _i587 in xrange(_size583): - _elem588 = NotificationEvent() - _elem588.read(iprot) - self.events.append(_elem588) + (_etype593, _size590) = iprot.readListBegin() + for _i594 in xrange(_size590): + _elem595 = NotificationEvent() + _elem595.read(iprot) + self.events.append(_elem595) iprot.readListEnd() else: iprot.skip(ftype) @@ -13045,8 +13239,8 @@ def write(self, oprot): if self.events is not None: oprot.writeFieldBegin('events', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.events)) - for iter589 in self.events: - iter589.write(oprot) + for iter596 in self.events: + iter596.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -13327,20 +13521,20 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.filesAdded = [] - (_etype593, _size590) = iprot.readListBegin() - for _i594 in xrange(_size590): - _elem595 = iprot.readString() - self.filesAdded.append(_elem595) + (_etype600, _size597) = iprot.readListBegin() + for _i601 in xrange(_size597): + _elem602 = iprot.readString() + self.filesAdded.append(_elem602) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.filesAddedChecksum = [] - (_etype599, _size596) = iprot.readListBegin() - for _i600 in xrange(_size596): - _elem601 = iprot.readString() - self.filesAddedChecksum.append(_elem601) + (_etype606, _size603) = iprot.readListBegin() + for _i607 in xrange(_size603): + _elem608 = iprot.readString() + self.filesAddedChecksum.append(_elem608) iprot.readListEnd() else: iprot.skip(ftype) @@ -13361,15 +13555,15 @@ def write(self, oprot): if self.filesAdded is not None: oprot.writeFieldBegin('filesAdded', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.filesAdded)) - for iter602 in self.filesAdded: - oprot.writeString(iter602) + for iter609 in self.filesAdded: + oprot.writeString(iter609) oprot.writeListEnd() oprot.writeFieldEnd() if self.filesAddedChecksum is not None: oprot.writeFieldBegin('filesAddedChecksum', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.filesAddedChecksum)) - for iter603 in self.filesAddedChecksum: - oprot.writeString(iter603) + for iter610 in self.filesAddedChecksum: + oprot.writeString(iter610) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -13524,10 +13718,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.partitionVals = [] - (_etype607, _size604) = iprot.readListBegin() - for _i608 in xrange(_size604): - _elem609 = iprot.readString() - self.partitionVals.append(_elem609) + (_etype614, _size611) = iprot.readListBegin() + for _i615 in xrange(_size611): + _elem616 = iprot.readString() + self.partitionVals.append(_elem616) iprot.readListEnd() else: iprot.skip(ftype) @@ -13560,8 +13754,8 @@ def write(self, oprot): if self.partitionVals is not None: oprot.writeFieldBegin('partitionVals', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.partitionVals)) - for iter610 in self.partitionVals: - oprot.writeString(iter610) + for iter617 in self.partitionVals: + oprot.writeString(iter617) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -13748,12 +13942,12 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.metadata = {} - (_ktype612, _vtype613, _size611 ) = iprot.readMapBegin() - for _i615 in xrange(_size611): - _key616 = iprot.readI64() - _val617 = MetadataPpdResult() - _val617.read(iprot) - self.metadata[_key616] = _val617 + (_ktype619, _vtype620, _size618 ) = iprot.readMapBegin() + for _i622 in xrange(_size618): + _key623 = iprot.readI64() + _val624 = MetadataPpdResult() + _val624.read(iprot) + self.metadata[_key623] = _val624 iprot.readMapEnd() else: iprot.skip(ftype) @@ -13775,9 +13969,9 @@ def write(self, oprot): if self.metadata is not None: oprot.writeFieldBegin('metadata', TType.MAP, 1) oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.metadata)) - for kiter618,viter619 in self.metadata.items(): - oprot.writeI64(kiter618) - viter619.write(oprot) + for kiter625,viter626 in self.metadata.items(): + oprot.writeI64(kiter625) + viter626.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.isSupported is not None: @@ -13847,10 +14041,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fileIds = [] - (_etype623, _size620) = iprot.readListBegin() - for _i624 in xrange(_size620): - _elem625 = iprot.readI64() - self.fileIds.append(_elem625) + (_etype630, _size627) = iprot.readListBegin() + for _i631 in xrange(_size627): + _elem632 = iprot.readI64() + self.fileIds.append(_elem632) iprot.readListEnd() else: iprot.skip(ftype) @@ -13882,8 +14076,8 @@ def write(self, oprot): if self.fileIds is not None: oprot.writeFieldBegin('fileIds', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.fileIds)) - for iter626 in self.fileIds: - oprot.writeI64(iter626) + for iter633 in self.fileIds: + oprot.writeI64(iter633) oprot.writeListEnd() oprot.writeFieldEnd() if self.expr is not None: @@ -13957,11 +14151,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.metadata = {} - (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin() - for _i631 in xrange(_size627): - _key632 = iprot.readI64() - _val633 = iprot.readString() - self.metadata[_key632] = _val633 + (_ktype635, _vtype636, _size634 ) = iprot.readMapBegin() + for _i638 in xrange(_size634): + _key639 = iprot.readI64() + _val640 = iprot.readString() + self.metadata[_key639] = _val640 iprot.readMapEnd() else: iprot.skip(ftype) @@ -13983,9 +14177,9 @@ def write(self, oprot): if self.metadata is not None: oprot.writeFieldBegin('metadata', TType.MAP, 1) oprot.writeMapBegin(TType.I64, TType.STRING, len(self.metadata)) - for kiter634,viter635 in self.metadata.items(): - oprot.writeI64(kiter634) - oprot.writeString(viter635) + for kiter641,viter642 in self.metadata.items(): + oprot.writeI64(kiter641) + oprot.writeString(viter642) oprot.writeMapEnd() oprot.writeFieldEnd() if self.isSupported is not None: @@ -14046,10 +14240,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fileIds = [] - (_etype639, _size636) = iprot.readListBegin() - for _i640 in xrange(_size636): - _elem641 = iprot.readI64() - self.fileIds.append(_elem641) + (_etype646, _size643) = iprot.readListBegin() + for _i647 in xrange(_size643): + _elem648 = iprot.readI64() + self.fileIds.append(_elem648) iprot.readListEnd() else: iprot.skip(ftype) @@ -14066,8 +14260,8 @@ def write(self, oprot): if self.fileIds is not None: oprot.writeFieldBegin('fileIds', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.fileIds)) - for iter642 in self.fileIds: - oprot.writeI64(iter642) + for iter649 in self.fileIds: + oprot.writeI64(iter649) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14173,20 +14367,20 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fileIds = [] - (_etype646, _size643) = iprot.readListBegin() - for _i647 in xrange(_size643): - _elem648 = iprot.readI64() - self.fileIds.append(_elem648) + (_etype653, _size650) = iprot.readListBegin() + for _i654 in xrange(_size650): + _elem655 = iprot.readI64() + self.fileIds.append(_elem655) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 2: if ftype == TType.LIST: self.metadata = [] - (_etype652, _size649) = iprot.readListBegin() - for _i653 in xrange(_size649): - _elem654 = iprot.readString() - self.metadata.append(_elem654) + (_etype659, _size656) = iprot.readListBegin() + for _i660 in xrange(_size656): + _elem661 = iprot.readString() + self.metadata.append(_elem661) iprot.readListEnd() else: iprot.skip(ftype) @@ -14208,15 +14402,15 @@ def write(self, oprot): if self.fileIds is not None: oprot.writeFieldBegin('fileIds', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.fileIds)) - for iter655 in self.fileIds: - oprot.writeI64(iter655) + for iter662 in self.fileIds: + oprot.writeI64(iter662) oprot.writeListEnd() oprot.writeFieldEnd() if self.metadata is not None: oprot.writeFieldBegin('metadata', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.metadata)) - for iter656 in self.metadata: - oprot.writeString(iter656) + for iter663 in self.metadata: + oprot.writeString(iter663) oprot.writeListEnd() oprot.writeFieldEnd() if self.type is not None: @@ -14324,10 +14518,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fileIds = [] - (_etype660, _size657) = iprot.readListBegin() - for _i661 in xrange(_size657): - _elem662 = iprot.readI64() - self.fileIds.append(_elem662) + (_etype667, _size664) = iprot.readListBegin() + for _i668 in xrange(_size664): + _elem669 = iprot.readI64() + self.fileIds.append(_elem669) iprot.readListEnd() else: iprot.skip(ftype) @@ -14344,8 +14538,8 @@ def write(self, oprot): if self.fileIds is not None: oprot.writeFieldBegin('fileIds', TType.LIST, 1) oprot.writeListBegin(TType.I64, len(self.fileIds)) - for iter663 in self.fileIds: - oprot.writeI64(iter663) + for iter670 in self.fileIds: + oprot.writeI64(iter670) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14574,11 +14768,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.functions = [] - (_etype667, _size664) = iprot.readListBegin() - for _i668 in xrange(_size664): - _elem669 = Function() - _elem669.read(iprot) - self.functions.append(_elem669) + (_etype674, _size671) = iprot.readListBegin() + for _i675 in xrange(_size671): + _elem676 = Function() + _elem676.read(iprot) + self.functions.append(_elem676) iprot.readListEnd() else: iprot.skip(ftype) @@ -14595,8 +14789,8 @@ def write(self, oprot): if self.functions is not None: oprot.writeFieldBegin('functions', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.functions)) - for iter670 in self.functions: - iter670.write(oprot) + for iter677 in self.functions: + iter677.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14648,10 +14842,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.values = [] - (_etype674, _size671) = iprot.readListBegin() - for _i675 in xrange(_size671): - _elem676 = iprot.readI32() - self.values.append(_elem676) + (_etype681, _size678) = iprot.readListBegin() + for _i682 in xrange(_size678): + _elem683 = iprot.readI32() + self.values.append(_elem683) iprot.readListEnd() else: iprot.skip(ftype) @@ -14668,8 +14862,8 @@ def write(self, oprot): if self.values is not None: oprot.writeFieldBegin('values', TType.LIST, 1) oprot.writeListBegin(TType.I32, len(self.values)) - for iter677 in self.values: - oprot.writeI32(iter677) + for iter684 in self.values: + oprot.writeI32(iter684) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14898,10 +15092,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.tblNames = [] - (_etype681, _size678) = iprot.readListBegin() - for _i682 in xrange(_size678): - _elem683 = iprot.readString() - self.tblNames.append(_elem683) + (_etype688, _size685) = iprot.readListBegin() + for _i689 in xrange(_size685): + _elem690 = iprot.readString() + self.tblNames.append(_elem690) iprot.readListEnd() else: iprot.skip(ftype) @@ -14928,8 +15122,8 @@ def write(self, oprot): if self.tblNames is not None: oprot.writeFieldBegin('tblNames', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tblNames)) - for iter684 in self.tblNames: - oprot.writeString(iter684) + for iter691 in self.tblNames: + oprot.writeString(iter691) oprot.writeListEnd() oprot.writeFieldEnd() if self.capabilities is not None: @@ -14989,11 +15183,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.tables = [] - (_etype688, _size685) = iprot.readListBegin() - for _i689 in xrange(_size685): - _elem690 = Table() - _elem690.read(iprot) - self.tables.append(_elem690) + (_etype695, _size692) = iprot.readListBegin() + for _i696 in xrange(_size692): + _elem697 = Table() + _elem697.read(iprot) + self.tables.append(_elem697) iprot.readListEnd() else: iprot.skip(ftype) @@ -15010,8 +15204,8 @@ def write(self, oprot): if self.tables is not None: oprot.writeFieldBegin('tables', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.tables)) - for iter691 in self.tables: - iter691.write(oprot) + for iter698 in self.tables: + iter698.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -15309,10 +15503,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.SET: self.tablesUsed = set() - (_etype695, _size692) = iprot.readSetBegin() - for _i696 in xrange(_size692): - _elem697 = iprot.readString() - self.tablesUsed.add(_elem697) + (_etype702, _size699) = iprot.readSetBegin() + for _i703 in xrange(_size699): + _elem704 = iprot.readString() + self.tablesUsed.add(_elem704) iprot.readSetEnd() else: iprot.skip(ftype) @@ -15339,8 +15533,8 @@ def write(self, oprot): if self.tablesUsed is not None: oprot.writeFieldBegin('tablesUsed', TType.SET, 1) oprot.writeSetBegin(TType.STRING, len(self.tablesUsed)) - for iter698 in self.tablesUsed: - oprot.writeString(iter698) + for iter705 in self.tablesUsed: + oprot.writeString(iter705) oprot.writeSetEnd() oprot.writeFieldEnd() if self.validTxnList is not None: @@ -16244,44 +16438,44 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.pools = [] - (_etype702, _size699) = iprot.readListBegin() - for _i703 in xrange(_size699): - _elem704 = WMPool() - _elem704.read(iprot) - self.pools.append(_elem704) + (_etype709, _size706) = iprot.readListBegin() + for _i710 in xrange(_size706): + _elem711 = WMPool() + _elem711.read(iprot) + self.pools.append(_elem711) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.mappings = [] - (_etype708, _size705) = iprot.readListBegin() - for _i709 in xrange(_size705): - _elem710 = WMMapping() - _elem710.read(iprot) - self.mappings.append(_elem710) + (_etype715, _size712) = iprot.readListBegin() + for _i716 in xrange(_size712): + _elem717 = WMMapping() + _elem717.read(iprot) + self.mappings.append(_elem717) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.triggers = [] - (_etype714, _size711) = iprot.readListBegin() - for _i715 in xrange(_size711): - _elem716 = WMTrigger() - _elem716.read(iprot) - self.triggers.append(_elem716) + (_etype721, _size718) = iprot.readListBegin() + for _i722 in xrange(_size718): + _elem723 = WMTrigger() + _elem723.read(iprot) + self.triggers.append(_elem723) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.poolTriggers = [] - (_etype720, _size717) = iprot.readListBegin() - for _i721 in xrange(_size717): - _elem722 = WMPoolTrigger() - _elem722.read(iprot) - self.poolTriggers.append(_elem722) + (_etype727, _size724) = iprot.readListBegin() + for _i728 in xrange(_size724): + _elem729 = WMPoolTrigger() + _elem729.read(iprot) + self.poolTriggers.append(_elem729) iprot.readListEnd() else: iprot.skip(ftype) @@ -16302,29 +16496,29 @@ def write(self, oprot): if self.pools is not None: oprot.writeFieldBegin('pools', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.pools)) - for iter723 in self.pools: - iter723.write(oprot) + for iter730 in self.pools: + iter730.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.mappings is not None: oprot.writeFieldBegin('mappings', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.mappings)) - for iter724 in self.mappings: - iter724.write(oprot) + for iter731 in self.mappings: + iter731.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.triggers is not None: oprot.writeFieldBegin('triggers', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.triggers)) - for iter725 in self.triggers: - iter725.write(oprot) + for iter732 in self.triggers: + iter732.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.poolTriggers is not None: oprot.writeFieldBegin('poolTriggers', TType.LIST, 5) oprot.writeListBegin(TType.STRUCT, len(self.poolTriggers)) - for iter726 in self.poolTriggers: - iter726.write(oprot) + for iter733 in self.poolTriggers: + iter733.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -16798,11 +16992,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.resourcePlans = [] - (_etype730, _size727) = iprot.readListBegin() - for _i731 in xrange(_size727): - _elem732 = WMResourcePlan() - _elem732.read(iprot) - self.resourcePlans.append(_elem732) + (_etype737, _size734) = iprot.readListBegin() + for _i738 in xrange(_size734): + _elem739 = WMResourcePlan() + _elem739.read(iprot) + self.resourcePlans.append(_elem739) iprot.readListEnd() else: iprot.skip(ftype) @@ -16819,8 +17013,8 @@ def write(self, oprot): if self.resourcePlans is not None: oprot.writeFieldBegin('resourcePlans', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.resourcePlans)) - for iter733 in self.resourcePlans: - iter733.write(oprot) + for iter740 in self.resourcePlans: + iter740.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17124,20 +17318,20 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.errors = [] - (_etype737, _size734) = iprot.readListBegin() - for _i738 in xrange(_size734): - _elem739 = iprot.readString() - self.errors.append(_elem739) + (_etype744, _size741) = iprot.readListBegin() + for _i745 in xrange(_size741): + _elem746 = iprot.readString() + self.errors.append(_elem746) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 2: if ftype == TType.LIST: self.warnings = [] - (_etype743, _size740) = iprot.readListBegin() - for _i744 in xrange(_size740): - _elem745 = iprot.readString() - self.warnings.append(_elem745) + (_etype750, _size747) = iprot.readListBegin() + for _i751 in xrange(_size747): + _elem752 = iprot.readString() + self.warnings.append(_elem752) iprot.readListEnd() else: iprot.skip(ftype) @@ -17154,15 +17348,15 @@ def write(self, oprot): if self.errors is not None: oprot.writeFieldBegin('errors', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.errors)) - for iter746 in self.errors: - oprot.writeString(iter746) + for iter753 in self.errors: + oprot.writeString(iter753) oprot.writeListEnd() oprot.writeFieldEnd() if self.warnings is not None: oprot.writeFieldBegin('warnings', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.warnings)) - for iter747 in self.warnings: - oprot.writeString(iter747) + for iter754 in self.warnings: + oprot.writeString(iter754) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17739,11 +17933,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.triggers = [] - (_etype751, _size748) = iprot.readListBegin() - for _i752 in xrange(_size748): - _elem753 = WMTrigger() - _elem753.read(iprot) - self.triggers.append(_elem753) + (_etype758, _size755) = iprot.readListBegin() + for _i759 in xrange(_size755): + _elem760 = WMTrigger() + _elem760.read(iprot) + self.triggers.append(_elem760) iprot.readListEnd() else: iprot.skip(ftype) @@ -17760,8 +17954,8 @@ def write(self, oprot): if self.triggers is not None: oprot.writeFieldBegin('triggers', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.triggers)) - for iter754 in self.triggers: - iter754.write(oprot) + for iter761 in self.triggers: + iter761.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() diff --git a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index 625baae566..ab78a5b92d 100644 --- a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -2133,12 +2133,16 @@ class OpenTxnRequest USER = 2 HOSTNAME = 3 AGENTINFO = 4 + REPLPOLICY = 5 + REPLSRCTXNID = 6 FIELDS = { NUM_TXNS => {:type => ::Thrift::Types::I32, :name => 'num_txns'}, USER => {:type => ::Thrift::Types::STRING, :name => 'user'}, HOSTNAME => {:type => ::Thrift::Types::STRING, :name => 'hostname'}, - AGENTINFO => {:type => ::Thrift::Types::STRING, :name => 'agentInfo', :default => %q"Unknown", :optional => true} + AGENTINFO => {:type => ::Thrift::Types::STRING, :name => 'agentInfo', :default => %q"Unknown", :optional => true}, + REPLPOLICY => {:type => ::Thrift::Types::STRING, :name => 'replPolicy', :optional => true}, + REPLSRCTXNID => {:type => ::Thrift::Types::LIST, :name => 'replSrcTxnId', :element => {:type => ::Thrift::Types::I64}, :optional => true} } def struct_fields; FIELDS; end @@ -2172,9 +2176,11 @@ end class AbortTxnRequest include ::Thrift::Struct, ::Thrift::Struct_Union TXNID = 1 + REPLPOLICY = 2 FIELDS = { - TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'} + TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'}, + REPLPOLICY => {:type => ::Thrift::Types::STRING, :name => 'replPolicy', :optional => true} } def struct_fields; FIELDS; end @@ -2206,6 +2212,42 @@ end class CommitTxnRequest include ::Thrift::Struct, ::Thrift::Struct_Union TXNID = 1 + REPLPOLICY = 2 + + FIELDS = { + TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'}, + REPLPOLICY => {:type => ::Thrift::Types::STRING, :name => 'replPolicy', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field txnid is unset!') unless @txnid + end + + ::Thrift::Struct.generate_accessors self +end + +class GetTargetTxnIdRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + TXNID = 1 + + FIELDS = { + TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field txnid is unset!') unless @txnid + end + + ::Thrift::Struct.generate_accessors self +end + +class GetTargetTxnIdResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + TXNID = 1 FIELDS = { TXNID => {:type => ::Thrift::Types::I64, :name => 'txnid'} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index ac71d0882f..cdac0687bc 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -74,6 +74,7 @@ import org.apache.hadoop.hive.metastore.cache.CachedStore; import org.apache.hadoop.hive.metastore.conf.MetastoreConf; import org.apache.hadoop.hive.metastore.conf.MetastoreConf.ConfVars; +import org.apache.hadoop.hive.metastore.events.AbortTxnEvent; import org.apache.hadoop.hive.metastore.events.AddIndexEvent; import org.apache.hadoop.hive.metastore.events.AddNotNullConstraintEvent; import org.apache.hadoop.hive.metastore.events.AddPartitionEvent; @@ -83,6 +84,7 @@ import org.apache.hadoop.hive.metastore.events.AlterIndexEvent; import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent; import org.apache.hadoop.hive.metastore.events.AlterTableEvent; +import org.apache.hadoop.hive.metastore.events.CommitTxnEvent; import org.apache.hadoop.hive.metastore.events.ConfigChangeEvent; import org.apache.hadoop.hive.metastore.events.CreateDatabaseEvent; import org.apache.hadoop.hive.metastore.events.CreateFunctionEvent; @@ -95,6 +97,7 @@ import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent; +import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; import org.apache.hadoop.hive.metastore.events.PreAddIndexEvent; import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent; import org.apache.hadoop.hive.metastore.events.PreAlterDatabaseEvent; @@ -155,7 +158,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; - import com.facebook.fb303.FacebookBase; import com.facebook.fb303.fb_status; import com.google.common.annotations.VisibleForTesting; @@ -6672,12 +6674,26 @@ public GetOpenTxnsInfoResponse get_open_txns_info() throws TException { @Override public OpenTxnsResponse open_txns(OpenTxnRequest rqst) throws TException { - return getTxnHandler().openTxns(rqst); + OpenTxnsResponse response = getTxnHandler().openTxns(rqst); + List txnIds = response.getTxn_ids(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners,EventType.OPEN_TXN, + new OpenTxnEvent(txnIds.iterator(),this)); + } + if (!transactionalListeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventType.OPEN_TXN, + new OpenTxnEvent(txnIds.iterator(),this)); + } + + return response; } @Override public void abort_txn(AbortTxnRequest rqst) throws TException { getTxnHandler().abortTxn(rqst); + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ABORT_TXN, + new AbortTxnEvent(rqst.getTxnid(), true, this)); } @Override @@ -6688,6 +6704,10 @@ public void abort_txns(AbortTxnsRequest rqst) throws TException { @Override public void commit_txn(CommitTxnRequest rqst) throws TException { getTxnHandler().commitTxn(rqst); + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.COMMIT_TXN, + new CommitTxnEvent(rqst.getTxnid(), this)); + } @Override diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 59c0cff1c2..eaa1e57701 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2247,12 +2247,23 @@ public ValidTxnWriteIdList getValidWriteIds(Long currentTxnId, List tabl @Override public long openTxn(String user) throws TException { - OpenTxnsResponse txns = openTxns(user, 1); + OpenTxnsResponse txns = openTxnsIntr(user, null, null, 1); return txns.getTxn_ids().get(0); } + @Override + public List replOpenTxn(String replPolicy, Iterator srcTxnIds, int numTxns) throws TException { + // As this is called from replication task, the user field is not used. + OpenTxnsResponse txns = openTxnsIntr(null, replPolicy, srcTxnIds, numTxns); + return txns.getTxn_ids(); + } + @Override public OpenTxnsResponse openTxns(String user, int numTxns) throws TException { + return openTxnsIntr(user, null, null, numTxns); + } + + private OpenTxnsResponse openTxnsIntr(String user, String replPolicy, Iterator srcTxnIds, int numTxns) throws TException { String hostname = null; try { hostname = InetAddress.getLocalHost().getHostName(); @@ -2260,18 +2271,39 @@ public OpenTxnsResponse openTxns(String user, int numTxns) throws TException { LOG.error("Unable to resolve my host name " + e.getMessage()); throw new RuntimeException(e); } - return client.open_txns(new OpenTxnRequest(numTxns, user, hostname)); + OpenTxnRequest rqst = new OpenTxnRequest(numTxns, user, hostname); + if (replPolicy != null) { + // need to set this only for replication tasks + rqst.setReplPolicy(replPolicy); + rqst.setReplSrcTxnId(Lists.newArrayList(srcTxnIds)); + } + return client.open_txns(rqst); + } + + @Override + public void rollbackTxn(long txnid, String replPolicy) throws NoSuchTxnException, TException { + AbortTxnRequest rqst = new AbortTxnRequest(txnid); + rqst.setReplPolicy(replPolicy); + client.abort_txn(rqst); } @Override public void rollbackTxn(long txnid) throws NoSuchTxnException, TException { - client.abort_txn(new AbortTxnRequest(txnid)); + rollbackTxn(txnid, null); + } + + @Override + public void commitTxn(long txnid, String replPolicy) + throws NoSuchTxnException, TxnAbortedException, TException { + CommitTxnRequest rqst = new CommitTxnRequest(txnid); + rqst.setReplPolicy(replPolicy); + client.commit_txn(rqst); } @Override public void commitTxn(long txnid) throws NoSuchTxnException, TxnAbortedException, TException { - client.commit_txn(new CommitTxnRequest(txnid)); + commitTxn(txnid, null); } @Override diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 43aeeb3212..1196f250a5 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -118,6 +118,8 @@ import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.hadoop.hive.metastore.utils.ObjectPair; import org.apache.thrift.TException; +import java.util.Iterator; +import java.util.List; /** * Wrapper around hive metastore thrift api @@ -1393,6 +1395,16 @@ ValidTxnWriteIdList getValidWriteIds(Long currentTxnId, List tablesList, */ long openTxn(String user) throws TException; + /** + * Initiate a transaction at the target cluster. + * @param replPolicy The replication policy to uniquely identify the source cluster. + * @param srcTxnIds The list of transaction ids at the source cluster + * @param numTxns Number of transaction ids in the iterator + * @return transaction identifiers + * @throws TException + */ + List replOpenTxn(String replPolicy, Iterator srcTxnIds, int numTxns) throws TException; + /** * Initiate a batch of transactions. It is not guaranteed that the * requested number of transactions will be instantiated. The system has a @@ -1431,6 +1443,18 @@ ValidTxnWriteIdList getValidWriteIds(Long currentTxnId, List tablesList, */ void rollbackTxn(long txnid) throws NoSuchTxnException, TException; + /** + * Rollback a transaction. This will also unlock any locks associated with + * this transaction. + * @param txnid id of transaction to be rolled back. + * @param replPolicy the replication policy to identify the source cluster + * @throws NoSuchTxnException if the requested transaction does not exist. + * Note that this can result from the transaction having timed out and been + * deleted. + * @throws TException + */ + void rollbackTxn(long txnid, String replPolicy) throws NoSuchTxnException, TException; + /** * Commit a transaction. This will also unlock any locks associated with * this transaction. @@ -1445,6 +1469,21 @@ ValidTxnWriteIdList getValidWriteIds(Long currentTxnId, List tablesList, void commitTxn(long txnid) throws NoSuchTxnException, TxnAbortedException, TException; + /** + * Commit a transaction. This will also unlock any locks associated with + * this transaction. + * @param txnid id of transaction to be committed. + * @param replPolicy the replication policy to identify the source cluster + * @throws NoSuchTxnException if the requested transaction does not exist. + * This can result fro the transaction having timed out and been deleted by + * the compactor. + * @throws TxnAbortedException if the requested transaction has been + * aborted. This can result from the transaction timing out. + * @throws TException + */ + void commitTxn(long txnid, String replPolicy) + throws NoSuchTxnException, TxnAbortedException, TException; + /** * Abort a list of transactions. This is for use by "ABORT TRANSACTIONS" in the grammar. * @throws TException diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java index 0e1620df03..824c2ca000 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java @@ -45,6 +45,9 @@ import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent; +import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; +import org.apache.hadoop.hive.metastore.events.CommitTxnEvent; +import org.apache.hadoop.hive.metastore.events.AbortTxnEvent; /** * This abstract class needs to be extended to provide implementation of actions that needs @@ -220,6 +223,33 @@ public void onAddNotNullConstraint(AddNotNullConstraintEvent addNotNullConstrain public void onDropConstraint(DropConstraintEvent dropConstraintEvent) throws MetaException { } + /** + * This will be called when a new transaction is started. + * @param openTxnEvent + * @throws MetaException + */ + public void onOpenTxn(OpenTxnEvent openTxnEvent) throws MetaException { + + } + + /** + * This will be called to commit a transaction. + * @param commitTxnEvent + * @throws MetaException + */ + public void onCommitTxn(CommitTxnEvent commitTxnEvent) throws MetaException { + + } + + /** + * This will be called to abort a transaction. + * @param abortTxnEvent + * @throws MetaException + */ + public void onAbortTxn(AbortTxnEvent abortTxnEvent) throws MetaException { + + } + @Override public Configuration getConf() { return this.conf; diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java index a640b34e4b..8017b5d7e1 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java @@ -44,6 +44,9 @@ import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; import org.apache.hadoop.hive.metastore.events.ListenerEvent; +import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; +import org.apache.hadoop.hive.metastore.events.CommitTxnEvent; +import org.apache.hadoop.hive.metastore.events.AbortTxnEvent; import java.util.List; import java.util.Map; @@ -179,6 +182,26 @@ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws listener.onAddNotNullConstraint((AddNotNullConstraintEvent)event); } }) + .put(EventType.OPEN_TXN, new EventNotifier() { + @Override + public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException { + listener.onOpenTxn((OpenTxnEvent)event); + } + }) + .put(EventType.COMMIT_TXN, new EventNotifier() { + @Override + public void notify(MetaStoreEventListener listener, ListenerEvent event) + throws MetaException { + listener.onCommitTxn((CommitTxnEvent) event); + } + }) + .put(EventType.ABORT_TXN, new EventNotifier() { + @Override + public void notify(MetaStoreEventListener listener, ListenerEvent event) + throws MetaException { + listener.onAbortTxn((AbortTxnEvent) event); + } + }) .build() ); diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AbortTxnEvent.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AbortTxnEvent.java new file mode 100644 index 0000000000..2c34fc961b --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AbortTxnEvent.java @@ -0,0 +1,48 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.metastore.events; + +import org.apache.hadoop.classification.InterfaceAudience; +import org.apache.hadoop.classification.InterfaceStability; +import org.apache.hadoop.hive.metastore.IHMSHandler; + +@InterfaceAudience.Public +@InterfaceStability.Stable +public class AbortTxnEvent extends ListenerEvent { + + private final Long txnId; + + /** + * + * @param transactionId Unique identification for the transaction just opened. + * @param status status of insert, true = success, false = failure + * @param handler handler that is firing the event + */ + public AbortTxnEvent(Long transactionId, boolean status, IHMSHandler handler) { + super(status, handler); + txnId = transactionId; + } + + /** + * @return Long txnId + */ + public Long getTxnId() { + return txnId; + } +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/CommitTxnEvent.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/CommitTxnEvent.java new file mode 100644 index 0000000000..e02e5b0b85 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/CommitTxnEvent.java @@ -0,0 +1,48 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.metastore.events; + +import org.apache.hadoop.classification.InterfaceAudience; +import org.apache.hadoop.classification.InterfaceStability; +import org.apache.hadoop.hive.metastore.IHMSHandler; + +@InterfaceAudience.Public +@InterfaceStability.Stable +public class CommitTxnEvent extends ListenerEvent { + + private final Long txnId; + + /** + * + * @param transactionId Unique identification for the transaction just opened. + * @param status status of insert, true = success, false = failure + * @param handler handler that is firing the event + */ + public CommitTxnEvent(Long transactionId, IHMSHandler handler) { + super(true, handler); + txnId = transactionId; + } + + /** + * @return Long txnId + */ + public Long getTxnId() { + return txnId; + } +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/OpenTxnEvent.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/OpenTxnEvent.java new file mode 100644 index 0000000000..2ec4a3bf0f --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/OpenTxnEvent.java @@ -0,0 +1,51 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.metastore.events; + +import org.apache.hadoop.classification.InterfaceAudience; +import org.apache.hadoop.classification.InterfaceStability; +import org.apache.hadoop.hive.metastore.IHMSHandler; +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; + +@InterfaceAudience.Public +@InterfaceStability.Stable +public class OpenTxnEvent extends ListenerEvent { + + private final List txnIds; + + /** + * + * @param txnIdsItr List of unique identification for the transaction just opened. + * @param handler handler that is firing the event + */ + public OpenTxnEvent(Iterator txnIdsItr, IHMSHandler handler) { + super(true, handler); + txnIds = Lists.newArrayList(txnIdsItr); + } + + /** + * @return Iterator txnIds + */ + public Iterator getTxnIdItr() { + return txnIds.iterator(); + } +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AbortTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AbortTxnMessage.java new file mode 100644 index 0000000000..24da6fceeb --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AbortTxnMessage.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging; + + +/** + * HCat message sent when an open transaction is done. + */ +public abstract class AbortTxnMessage extends EventMessage { + + protected AbortTxnMessage() { + super(EventType.ABORT_TXN); + } + + /** + * Get the table object associated with the insert + * + * @return The TxnId + */ + public abstract Long getTxnId(); + +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/CommitTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/CommitTxnMessage.java new file mode 100644 index 0000000000..25591af990 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/CommitTxnMessage.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging; + + +/** + * HCat message sent when an commit transaction is done. + */ +public abstract class CommitTxnMessage extends EventMessage { + + protected CommitTxnMessage() { + super(EventType.COMMIT_TXN); + } + + /** + * Get the table object associated with the insert + * + * @return The TxnId + */ + public abstract Long getTxnId(); + +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java index dad2f5b115..c3bd5822f5 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java @@ -49,7 +49,10 @@ ADD_FOREIGNKEY(MessageFactory.ADD_FOREIGNKEY_EVENT), ADD_UNIQUECONSTRAINT(MessageFactory.ADD_UNIQUECONSTRAINT_EVENT), ADD_NOTNULLCONSTRAINT(MessageFactory.ADD_NOTNULLCONSTRAINT_EVENT), - DROP_CONSTRAINT(MessageFactory.DROP_CONSTRAINT_EVENT); + DROP_CONSTRAINT(MessageFactory.DROP_CONSTRAINT_EVENT), + OPEN_TXN(MessageFactory.OPEN_TXN_EVENT), + COMMIT_TXN(MessageFactory.COMMIT_TXN_EVENT), + ABORT_TXN(MessageFactory.ABORT_TXN_EVENT); private String typeString; diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageDeserializer.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageDeserializer.java index f85dc407c8..f5d2f23729 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageDeserializer.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageDeserializer.java @@ -70,6 +70,12 @@ public EventMessage getEventMessage(String eventTypeString, String messageBody) return getAddNotNullConstraintMessage(messageBody); case DROP_CONSTRAINT: return getDropConstraintMessage(messageBody); + case OPEN_TXN: + return getOpenTxnMessage(messageBody); + case COMMIT_TXN: + return getCommitTxnMessage(messageBody); + case ABORT_TXN: + return getAbortTxnMessage(messageBody); default: throw new IllegalArgumentException("Unsupported event-type: " + eventTypeString); } @@ -181,6 +187,21 @@ public EventMessage getEventMessage(String eventTypeString, String messageBody) */ public abstract DropConstraintMessage getDropConstraintMessage(String messageBody); + /** + * Method to de-serialize OpenTxnMessage instance. + */ + public abstract OpenTxnMessage getOpenTxnMessage(String messageBody); + + /** + * Method to de-serialize CommitTxnMessage instance. + */ + public abstract CommitTxnMessage getCommitTxnMessage(String messageBody); + + /** + * Method to de-serialize AbortTxnMessage instance. + */ + public abstract AbortTxnMessage getAbortTxnMessage(String messageBody); + // Protection against construction. protected MessageDeserializer() {} } diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java index 0e3357d487..9571dec811 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java @@ -63,6 +63,9 @@ public static final String ADD_UNIQUECONSTRAINT_EVENT = "ADD_UNIQUECONSTRAINT"; public static final String ADD_NOTNULLCONSTRAINT_EVENT = "ADD_NOTNULLCONSTRAINT"; public static final String DROP_CONSTRAINT_EVENT = "DROP_CONSTRAINT"; + public static final String OPEN_TXN_EVENT = "OPEN_TXN"; + public static final String COMMIT_TXN_EVENT = "COMMIT_TXN"; + public static final String ABORT_TXN_EVENT = "ABORT_TXN"; private static MessageFactory instance = null; @@ -254,6 +257,30 @@ public abstract AlterPartitionMessage buildAlterPartitionMessage(Table table, Pa public abstract InsertMessage buildInsertMessage(Table tableObj, Partition ptnObj, boolean replace, Iterator files); + /** + * Factory method for building open txn message + * + * @param txnIdsItr List of ids of the newly opened transactions + * @return instance of OpenTxnMessage + */ + public abstract OpenTxnMessage buildOpenTxnMessage(Iterator txnIdsItr); + + /** + * Factory method for building commit txn message + * + * @param txnId Id of the transaction to be committed + * @return instance of CommitTxnMessage + */ + public abstract CommitTxnMessage buildCommitTxnMessage(Long txnId); + + /** + * Factory method for building abort txn message + * + * @param txnId Id of the transaction to be aborted + * @return instance of AbortTxnMessage + */ + public abstract AbortTxnMessage buildAbortTxnMessage(Long txnId); + /*** * Factory method for building add primary key message * diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/OpenTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/OpenTxnMessage.java new file mode 100644 index 0000000000..f7ce724456 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/OpenTxnMessage.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging; + +import java.util.Iterator; +import java.util.List; + +/** + * HCat message sent when an open transaction is done. + */ +public abstract class OpenTxnMessage extends EventMessage { + + protected OpenTxnMessage() { + super(EventType.OPEN_TXN); + } + + /** + * Get the list of transactios opened + * + * @return The lists of TxnIds + */ + abstract public Iterator getTxnIdItr(); +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/event/filters/DatabaseAndTableFilter.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/event/filters/DatabaseAndTableFilter.java index 50420c8d37..64402e2999 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/event/filters/DatabaseAndTableFilter.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/event/filters/DatabaseAndTableFilter.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.metastore.messaging.event.filters; import org.apache.hadoop.hive.metastore.api.NotificationEvent; +import org.apache.hadoop.hive.metastore.messaging.MessageFactory; import java.util.regex.Pattern; @@ -39,10 +40,17 @@ public DatabaseAndTableFilter(final String databaseNameOrPattern, final String t this.tableName = tableName; } + private boolean isTxnRelatedEvent(final NotificationEvent event) { + return ((event.getEventType().equals(MessageFactory.OPEN_TXN_EVENT)) || + (event.getEventType().equals(MessageFactory.COMMIT_TXN_EVENT)) || + (event.getEventType().equals(MessageFactory.ABORT_TXN_EVENT)) + ); + } + @Override boolean shouldAccept(final NotificationEvent event) { - if (dbPattern == null) { - return true; // if our dbName is null, we're interested in all wh events + if ((dbPattern == null) || isTxnRelatedEvent(event)) { + return true; // if our dbName is null or its of open txn type, we're interested in all wh events } if (dbPattern.matcher(event.getDbName()).matches()) { if ((tableName == null) diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAbortTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAbortTxnMessage.java new file mode 100644 index 0000000000..8a33e2b8b5 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAbortTxnMessage.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging.json; +import org.apache.hadoop.hive.metastore.messaging.AbortTxnMessage; +import org.codehaus.jackson.annotate.JsonProperty; + +/** + * JSON implementation of AbortTxnMessage + */ +public class JSONAbortTxnMessage extends AbortTxnMessage { + + @JsonProperty + Long txnid; + + @JsonProperty + Long timestamp; + + @JsonProperty + String server; + + @JsonProperty + String servicePrincipal; + + /** + * Default constructor, needed for Jackson. + */ + public JSONAbortTxnMessage() { + } + + public JSONAbortTxnMessage(String server, String servicePrincipal, Long txnid, Long timestamp) { + this.timestamp = timestamp; + this.txnid = txnid; + this.server = server; + this.servicePrincipal = servicePrincipal; + } + + @Override + public Long getTxnId() { return txnid; } + + + @Override + public Long getTimestamp() { + return timestamp; + } + + @Override + public String getDB() { + return null; + } + + @Override + public String getServicePrincipal() { + return servicePrincipal; + } + + @Override + public String getServer() { + return server; + } + + @Override + public String toString() { + try { + return JSONMessageDeserializer.mapper.writeValueAsString(this); + } catch (Exception exception) { + throw new IllegalArgumentException("Could not serialize: ", exception); + } + } + +} \ No newline at end of file diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONCommitTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONCommitTxnMessage.java new file mode 100644 index 0000000000..c00815a573 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONCommitTxnMessage.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging.json; +import org.apache.hadoop.hive.metastore.messaging.CommitTxnMessage; +import org.codehaus.jackson.annotate.JsonProperty; + +/** + * JSON implementation of CommitTxnMessage + */ +public class JSONCommitTxnMessage extends CommitTxnMessage { + + @JsonProperty + Long txnid; + + @JsonProperty + Long timestamp; + + @JsonProperty + String server; + + @JsonProperty + String servicePrincipal; + + /** + * Default constructor, needed for Jackson. + */ + public JSONCommitTxnMessage() { + } + + public JSONCommitTxnMessage(String server, String servicePrincipal, Long txnid, Long timestamp) { + this.timestamp = timestamp; + this.txnid = txnid; + this.server = server; + this.servicePrincipal = servicePrincipal; + } + + @Override + public Long getTxnId() { return txnid; } + + + @Override + public Long getTimestamp() { + return timestamp; + } + + @Override + public String getDB() { + return null; + } + + @Override + public String getServicePrincipal() { + return servicePrincipal; + } + + @Override + public String getServer() { + return server; + } + + @Override + public String toString() { + try { + return JSONMessageDeserializer.mapper.writeValueAsString(this); + } catch (Exception exception) { + throw new IllegalArgumentException("Could not serialize: ", exception); + } + } + +} \ No newline at end of file diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageDeserializer.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageDeserializer.java index 34b62e6901..0542e1f2bd 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageDeserializer.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageDeserializer.java @@ -40,6 +40,9 @@ import org.apache.hadoop.hive.metastore.messaging.DropTableMessage; import org.apache.hadoop.hive.metastore.messaging.InsertMessage; import org.apache.hadoop.hive.metastore.messaging.MessageDeserializer; +import org.apache.hadoop.hive.metastore.messaging.OpenTxnMessage; +import org.apache.hadoop.hive.metastore.messaging.CommitTxnMessage; +import org.apache.hadoop.hive.metastore.messaging.AbortTxnMessage; import org.codehaus.jackson.map.DeserializationConfig; import org.codehaus.jackson.map.ObjectMapper; import org.codehaus.jackson.map.SerializationConfig; @@ -253,4 +256,31 @@ public DropConstraintMessage getDropConstraintMessage(String messageBody) { throw new IllegalArgumentException("Could not construct DropConstraintMessage", e); } } + + @Override + public OpenTxnMessage getOpenTxnMessage(String messageBody) { + try { + return mapper.readValue(messageBody, JSONOpenTxnMessage.class); + } catch (Exception e) { + throw new IllegalArgumentException("Could not construct OpenTxnMessage", e); + } + } + + @Override + public CommitTxnMessage getCommitTxnMessage(String messageBody) { + try { + return mapper.readValue(messageBody, JSONCommitTxnMessage.class); + } catch (Exception e) { + throw new IllegalArgumentException("Could not construct CommitTxnMessage", e); + } + } + + @Override + public AbortTxnMessage getAbortTxnMessage(String messageBody) { + try { + return mapper.readValue(messageBody, JSONAbortTxnMessage.class); + } catch (Exception e) { + throw new IllegalArgumentException("Could not construct AbortTxnMessage", e); + } + } } diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java index 7f46d071fe..8746e0f9d4 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java @@ -61,6 +61,9 @@ import org.apache.hadoop.hive.metastore.messaging.MessageDeserializer; import org.apache.hadoop.hive.metastore.messaging.MessageFactory; import org.apache.hadoop.hive.metastore.messaging.PartitionFiles; +import org.apache.hadoop.hive.metastore.messaging.OpenTxnMessage; +import org.apache.hadoop.hive.metastore.messaging.CommitTxnMessage; +import org.apache.hadoop.hive.metastore.messaging.AbortTxnMessage; import org.apache.thrift.TBase; import org.apache.thrift.TDeserializer; import org.apache.thrift.TException; @@ -209,6 +212,21 @@ public DropConstraintMessage buildDropConstraintMessage(String dbName, String ta constraintName, now()); } + @Override + public OpenTxnMessage buildOpenTxnMessage(Iterator txnIdsItr) { + return new JSONOpenTxnMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, txnIdsItr, now()); + } + + @Override + public CommitTxnMessage buildCommitTxnMessage(Long txnId) { + return new JSONCommitTxnMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, txnId, now()); + } + + @Override + public AbortTxnMessage buildAbortTxnMessage(Long txnId) { + return new JSONAbortTxnMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, txnId, now()); + } + private long now() { return System.currentTimeMillis() / 1000; } diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONOpenTxnMessage.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONOpenTxnMessage.java new file mode 100644 index 0000000000..0393b25849 --- /dev/null +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONOpenTxnMessage.java @@ -0,0 +1,90 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hadoop.hive.metastore.messaging.json; +import org.apache.hadoop.hive.metastore.messaging.OpenTxnMessage; +import org.codehaus.jackson.annotate.JsonProperty; + +import com.google.common.collect.Lists; + +import java.util.Iterator; +import java.util.List; + +/** + * JSON implementation of OpenTxnMessage + */ +public class JSONOpenTxnMessage extends OpenTxnMessage { + + @JsonProperty + List txnIds; + + @JsonProperty + Long timestamp; + + @JsonProperty + String server; + + @JsonProperty + String servicePrincipal; + + /** + * Default constructor, needed for Jackson. + */ + public JSONOpenTxnMessage() { + } + + public JSONOpenTxnMessage(String server, String servicePrincipal, Iterator txnIdsItr, Long timestamp) { + this.timestamp = timestamp; + this.txnIds = Lists.newArrayList(txnIdsItr); + this.server = server; + this.servicePrincipal = servicePrincipal; + } + + @Override + public Iterator getTxnIdItr() { return txnIds.iterator(); } + + @Override + public Long getTimestamp() { + return timestamp; + } + + @Override + public String getDB() { + return null; + } + + @Override + public String getServicePrincipal() { + return servicePrincipal; + } + + @Override + public String getServer() { + return server; + } + + @Override + public String toString() { + try { + return JSONMessageDeserializer.mapper.writeValueAsString(this); + } catch (Exception exception) { + throw new IllegalArgumentException("Could not serialize: ", exception); + } + } +} diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java index 6a745948a3..f475a7ac9c 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/txn/TxnHandler.java @@ -584,6 +584,32 @@ public OpenTxnsResponse openTxns(OpenTxnRequest rqst) throws MetaException { LOG.debug("Going to execute update <" + q + ">"); stmt.execute(q); } + + if (rqst.isSetReplPolicy()) { + List rowsRepl = new ArrayList<>(); + List selectRepl = new ArrayList<>(); + + for (int i = 0; i < numTxns; i++) { + selectRepl.add("select TM_TARGET_TXN_ID from REPL_TXN_MAP where TM_REPL_POLICY = " + quoteString( + rqst.getReplPolicy()) + "and TM_SRC_TXN_ID = " + rqst.getReplSrcTxnId().get(i)); + long txnId = i + first; + rowsRepl.add( + quoteString(rqst.getReplPolicy()) + "," + rqst.getReplSrcTxnId().get(i) + "," + txnId); + } + + List queriesRepl = sqlGenerator.createInsertValuesStmt( + "REPL_TXN_MAP (TM_REPL_POLICY, tm_src_txn_id, TM_TARGET_TXN_ID)", rowsRepl); + + for (int i = 0; i < numTxns; i++) { + rs = stmt.executeQuery(selectRepl.get(i)); + //no rows in the result set + if (!rs.next()) { + LOG.debug("Going to execute insert <" + queriesRepl.get(i) + ">"); + stmt.execute(queriesRepl.get(i)); + } + } + } + LOG.debug("Going to commit"); dbConn.commit(); return new OpenTxnsResponse(txnIds); @@ -604,15 +630,34 @@ public OpenTxnsResponse openTxns(OpenTxnRequest rqst) throws MetaException { @Override @RetrySemantics.Idempotent public void abortTxn(AbortTxnRequest rqst) throws NoSuchTxnException, MetaException, TxnAbortedException { - long txnid = rqst.getTxnid(); + long txnid; + long sourceTxnId = -1; + ResultSet rs; try { Connection dbConn = null; Statement stmt = null; try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); + stmt = dbConn.createStatement(); + + if (rqst.isSetReplPolicy()) { + sourceTxnId = rqst.getTxnid(); + String query = "select TM_TARGET_TXN_ID from REPL_TXN_MAP where TM_SRC_TXN_ID = " + sourceTxnId + + " and TM_REPL_POLICY = " + quoteString(rqst.getReplPolicy()); + String s = sqlGenerator.addForUpdateClause(query); + LOG.debug("Going to execute query <" + s + ">"); + rs = stmt.executeQuery(s); + if (!rs.next()) { + LOG.debug("Target txn for Transaction not present <" + quoteString(rqst.getReplPolicy()) +":" +sourceTxnId + ">"); + return; + } + txnid = rs.getLong(1); + } else { + txnid = rqst.getTxnid(); + } + if (abortTxns(dbConn, Collections.singletonList(txnid), true) != 1) { - stmt = dbConn.createStatement(); TxnStatus status = findTxnState(txnid,stmt); if(status == TxnStatus.ABORTED) { LOG.info("abortTxn(" + JavaUtils.txnIdToString(txnid) + @@ -622,6 +667,13 @@ public void abortTxn(AbortTxnRequest rqst) throws NoSuchTxnException, MetaExcept raiseTxnUnexpectedState(status, txnid); } + if (rqst.isSetReplPolicy()) { + String s = "delete from REPL_TXN_MAP where TM_SRC_TXN_ID = " + sourceTxnId + + " and TM_REPL_POLICY = " + quoteString(rqst.getReplPolicy()); + LOG.debug("Going to execute <" + s + ">"); + stmt.executeUpdate(s); + } + LOG.debug("Going to commit"); dbConn.commit(); } catch (SQLException e) { @@ -698,7 +750,8 @@ public void abortTxns(AbortTxnsRequest rqst) throws NoSuchTxnException, MetaExce @RetrySemantics.Idempotent("No-op if already committed") public void commitTxn(CommitTxnRequest rqst) throws NoSuchTxnException, TxnAbortedException, MetaException { - long txnid = rqst.getTxnid(); + long txnid; + long sourceTxnId = -1; try { Connection dbConn = null; Statement stmt = null; @@ -708,6 +761,23 @@ public void commitTxn(CommitTxnRequest rqst) lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); + + if (rqst.isSetReplPolicy()) { + sourceTxnId = rqst.getTxnid(); + String query = "select TM_TARGET_TXN_ID from REPL_TXN_MAP where TM_SRC_TXN_ID = " + sourceTxnId + + " and TM_REPL_POLICY = " + quoteString(rqst.getReplPolicy()); + String s = sqlGenerator.addForUpdateClause(query); + LOG.debug("Going to execute query <" + s + ">"); + rs = stmt.executeQuery(s); + if (!rs.next()) { + LOG.debug("Target txn for Transaction not present <" + quoteString(rqst.getReplPolicy()) +":" +sourceTxnId + ">"); + return; + } + txnid = rs.getLong(1); + } else { + txnid = rqst.getTxnid(); + } + /** * Runs at READ_COMMITTED with S4U on TXNS row for "txnid". S4U ensures that no other * operation can change this txn (such acquiring locks). While lock() and commitTxn() @@ -857,6 +927,14 @@ public void commitTxn(CommitTxnRequest rqst) rs.getString(1), rs.getString(2), txnid, rs.getTimestamp(3, Calendar.getInstance(TimeZone.getTimeZone("UTC"))).getTime()); } + + if (rqst.isSetReplPolicy()) { + s = "delete from REPL_TXN_MAP where TM_SRC_TXN_ID = " + sourceTxnId + + " and TM_REPL_POLICY = " + quoteString(rqst.getReplPolicy()); + LOG.debug("Going to execute <" + s + ">"); + stmt.executeUpdate(s); + } + close(rs); dbConn.commit(); } catch (SQLException e) { diff --git a/standalone-metastore/src/main/sql/derby/hive-schema-3.0.0.derby.sql b/standalone-metastore/src/main/sql/derby/hive-schema-3.0.0.derby.sql index 9d8a703b33..89ebb47826 100644 --- a/standalone-metastore/src/main/sql/derby/hive-schema-3.0.0.derby.sql +++ b/standalone-metastore/src/main/sql/derby/hive-schema-3.0.0.derby.sql @@ -544,6 +544,12 @@ CREATE TABLE NEXT_WRITE_ID ( CREATE UNIQUE INDEX NEXT_WRITE_ID_IDX ON NEXT_WRITE_ID (NWI_DATABASE, NWI_TABLE); +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); -- ----------------------------------------------------------------- -- Record schema version. Should be the last step in the init script -- ----------------------------------------------------------------- diff --git a/standalone-metastore/src/main/sql/derby/upgrade-2.3.0-to-3.0.0.derby.sql b/standalone-metastore/src/main/sql/derby/upgrade-2.3.0-to-3.0.0.derby.sql index a50c45d4a0..b3671fa27f 100644 --- a/standalone-metastore/src/main/sql/derby/upgrade-2.3.0-to-3.0.0.derby.sql +++ b/standalone-metastore/src/main/sql/derby/upgrade-2.3.0-to-3.0.0.derby.sql @@ -120,3 +120,10 @@ RENAME COLUMN COMPLETED_COMPACTIONS.CC_HIGHEST_TXN_ID TO CC_HIGHEST_WRITE_ID; -- Modify txn_components/completed_txn_components tables to add write id. ALTER TABLE TXN_COMPONENTS ADD TC_WRITEID bigint; ALTER TABLE COMPLETED_TXN_COMPONENTS ADD CTC_WRITEID bigint; + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); diff --git a/standalone-metastore/src/main/sql/mssql/hive-schema-3.0.0.mssql.sql b/standalone-metastore/src/main/sql/mssql/hive-schema-3.0.0.mssql.sql index 1b7d0da1cc..c2b952f69d 100644 --- a/standalone-metastore/src/main/sql/mssql/hive-schema-3.0.0.mssql.sql +++ b/standalone-metastore/src/main/sql/mssql/hive-schema-3.0.0.mssql.sql @@ -1148,6 +1148,14 @@ CREATE TABLE NEXT_WRITE_ID ( CREATE UNIQUE INDEX NEXT_WRITE_ID_IDX ON NEXT_WRITE_ID (NWI_DATABASE, NWI_TABLE); +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY nvarchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL +); + +ALTER TABLE REPL_TXN_MAP ADD CONSTRAINT REPL_TXN_MAP_PK PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID); + -- ----------------------------------------------------------------- -- Record schema version. Should be the last step in the init script -- ----------------------------------------------------------------- diff --git a/standalone-metastore/src/main/sql/mssql/upgrade-2.3.0-to-3.0.0.mssql.sql b/standalone-metastore/src/main/sql/mssql/upgrade-2.3.0-to-3.0.0.mssql.sql index 8ab466d5e7..c0067bd670 100644 --- a/standalone-metastore/src/main/sql/mssql/upgrade-2.3.0-to-3.0.0.mssql.sql +++ b/standalone-metastore/src/main/sql/mssql/upgrade-2.3.0-to-3.0.0.mssql.sql @@ -174,3 +174,11 @@ EXEC SP_RENAME 'COMPLETED_COMPACTIONS.CC_HIGHEST_TXN_ID', 'CC_HIGHEST_WRITE_ID', -- Modify txn_components/completed_txn_components tables to add write id. ALTER TABLE TXN_COMPONENTS ADD TC_WRITEID bigint; ALTER TABLE COMPLETED_TXN_COMPONENTS ADD CTC_WRITEID bigint; + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY nvarchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL +); + +ALTER TABLE REPL_TXN_MAP ADD CONSTRAINT REPL_TXN_MAP_PK PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID); diff --git a/standalone-metastore/src/main/sql/mysql/hive-schema-3.0.0.mysql.sql b/standalone-metastore/src/main/sql/mysql/hive-schema-3.0.0.mysql.sql index 886c93262b..99eb090a23 100644 --- a/standalone-metastore/src/main/sql/mysql/hive-schema-3.0.0.mysql.sql +++ b/standalone-metastore/src/main/sql/mysql/hive-schema-3.0.0.mysql.sql @@ -1083,6 +1083,13 @@ CREATE TABLE NEXT_WRITE_ID ( CREATE UNIQUE INDEX NEXT_WRITE_ID_IDX ON NEXT_WRITE_ID (NWI_DATABASE, NWI_TABLE); +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + -- ----------------------------------------------------------------- -- Record schema version. Should be the last step in the init script -- ----------------------------------------------------------------- diff --git a/standalone-metastore/src/main/sql/mysql/upgrade-2.3.0-to-3.0.0.mysql.sql b/standalone-metastore/src/main/sql/mysql/upgrade-2.3.0-to-3.0.0.mysql.sql index a5377342aa..1308062115 100644 --- a/standalone-metastore/src/main/sql/mysql/upgrade-2.3.0-to-3.0.0.mysql.sql +++ b/standalone-metastore/src/main/sql/mysql/upgrade-2.3.0-to-3.0.0.mysql.sql @@ -159,3 +159,10 @@ ALTER TABLE COMPLETED_COMPACTIONS CHANGE `CC_HIGHEST_TXN_ID` `CC_HIGHEST_WRITE_I -- Modify txn_components/completed_txn_components tables to add write id. ALTER TABLE TXN_COMPONENTS ADD TC_WRITEID bigint; ALTER TABLE COMPLETED_TXN_COMPONENTS ADD CTC_WRITEID bigint; + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; diff --git a/standalone-metastore/src/main/sql/oracle/hive-schema-3.0.0.oracle.sql b/standalone-metastore/src/main/sql/oracle/hive-schema-3.0.0.oracle.sql index 366b2d90a0..1b6697c130 100644 --- a/standalone-metastore/src/main/sql/oracle/hive-schema-3.0.0.oracle.sql +++ b/standalone-metastore/src/main/sql/oracle/hive-schema-3.0.0.oracle.sql @@ -1056,6 +1056,13 @@ CREATE TABLE NEXT_WRITE_ID ( CREATE UNIQUE INDEX NEXT_WRITE_ID_IDX ON NEXT_WRITE_ID (NWI_DATABASE, NWI_TABLE); +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID number(19) NOT NULL, + TM_TARGET_TXN_ID number(19) NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); + -- ----------------------------------------------------------------- -- Record schema version. Should be the last step in the init script -- ----------------------------------------------------------------- diff --git a/standalone-metastore/src/main/sql/oracle/upgrade-2.3.0-to-3.0.0.oracle.sql b/standalone-metastore/src/main/sql/oracle/upgrade-2.3.0-to-3.0.0.oracle.sql index bd786fb03d..8dfeff8417 100644 --- a/standalone-metastore/src/main/sql/oracle/upgrade-2.3.0-to-3.0.0.oracle.sql +++ b/standalone-metastore/src/main/sql/oracle/upgrade-2.3.0-to-3.0.0.oracle.sql @@ -182,3 +182,10 @@ ALTER TABLE COMPLETED_COMPACTIONS RENAME COLUMN CC_HIGHEST_TXN_ID TO CC_HIGHEST_ -- Modify txn_components/completed_txn_components tables to add write id. ALTER TABLE TXN_COMPONENTS ADD TC_WRITEID number(19); ALTER TABLE COMPLETED_TXN_COMPONENTS ADD CTC_WRITEID number(19); + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID number(19) NOT NULL, + TM_TARGET_TXN_ID number(19) NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); diff --git a/standalone-metastore/src/main/sql/postgres/hive-schema-3.0.0.postgres.sql b/standalone-metastore/src/main/sql/postgres/hive-schema-3.0.0.postgres.sql index 4abf24c96b..e67368285a 100644 --- a/standalone-metastore/src/main/sql/postgres/hive-schema-3.0.0.postgres.sql +++ b/standalone-metastore/src/main/sql/postgres/hive-schema-3.0.0.postgres.sql @@ -1748,6 +1748,13 @@ CREATE TABLE NEXT_WRITE_ID ( CREATE UNIQUE INDEX NEXT_WRITE_ID_IDX ON NEXT_WRITE_ID (NWI_DATABASE, NWI_TABLE); +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); + -- ----------------------------------------------------------------- -- Record schema version. Should be the last step in the init script -- ----------------------------------------------------------------- diff --git a/standalone-metastore/src/main/sql/postgres/upgrade-2.3.0-to-3.0.0.postgres.sql b/standalone-metastore/src/main/sql/postgres/upgrade-2.3.0-to-3.0.0.postgres.sql index 34ed9742fa..ef64a74d0e 100644 --- a/standalone-metastore/src/main/sql/postgres/upgrade-2.3.0-to-3.0.0.postgres.sql +++ b/standalone-metastore/src/main/sql/postgres/upgrade-2.3.0-to-3.0.0.postgres.sql @@ -198,3 +198,10 @@ ALTER TABLE COMPLETED_COMPACTIONS RENAME CC_HIGHEST_TXN_ID TO CC_HIGHEST_WRITE_I -- Modify txn_components/completed_txn_components tables to add write id. ALTER TABLE TXN_COMPONENTS ADD TC_WRITEID bigint; ALTER TABLE COMPLETED_TXN_COMPONENTS ADD CTC_WRITEID bigint; + +CREATE TABLE REPL_TXN_MAP ( + TM_REPL_POLICY varchar(128) NOT NULL, + TM_SRC_TXN_ID bigint NOT NULL, + TM_TARGET_TXN_ID bigint NOT NULL, + PRIMARY KEY (TM_REPL_POLICY, TM_SRC_TXN_ID) +); diff --git a/standalone-metastore/src/main/thrift/hive_metastore.thrift b/standalone-metastore/src/main/thrift/hive_metastore.thrift index b11ee380b4..e25a93eb97 100644 --- a/standalone-metastore/src/main/thrift/hive_metastore.thrift +++ b/standalone-metastore/src/main/thrift/hive_metastore.thrift @@ -713,6 +713,8 @@ struct OpenTxnRequest { 2: required string user, 3: required string hostname, 4: optional string agentInfo = "Unknown", + 5: optional string replPolicy, + 6: optional list replSrcTxnId, } struct OpenTxnsResponse { @@ -721,6 +723,7 @@ struct OpenTxnsResponse { struct AbortTxnRequest { 1: required i64 txnid, + 2: optional string replPolicy, } struct AbortTxnsRequest { @@ -729,6 +732,15 @@ struct AbortTxnsRequest { struct CommitTxnRequest { 1: required i64 txnid, + 2: optional string replPolicy, +} + +struct GetTargetTxnIdRequest { + 1: required i64 txnid, +} + +struct GetTargetTxnIdResponse { + 1: required i64 txnid, } // Request msg to get the valid write ids list for the given list of tables wrt to input validTxnList